From 467997f9da80f6892a850980f950880edad8a7a9 Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Thu, 2 Feb 2017 00:28:24 +0100
Subject: [PATCH 01/26] Created dev branch for further testing.

---
 dist/bin/handlers.d.ts                        |     0
 dist/bin/handlers.js                          |    50 +
 dist/bin/index.d.ts                           |     1 +
 dist/bin/index.js                             |    58 +
 dist/bin/status.d.ts                          |     0
 dist/bin/status.js                            |    98 +
 dist/bus.d.ts                                 |     1 +
 dist/bus.js                                   |     4 +
 dist/bus/Bus.d.ts                             |     6 +
 dist/bus/Bus.js                               |     8 +
 dist/compiler.d.ts                            |     6 +
 dist/compiler.js                              |     7 +
 dist/compiler/Compiler.d.ts                   |    16 +
 dist/compiler/Compiler.js                     |    95 +
 dist/compiler/CompilerConfig.d.ts             |     9 +
 dist/compiler/CompilerConfig.js               |     1 +
 dist/compiler/CompilerMode.d.ts               |     5 +
 dist/compiler/CompilerMode.js                 |     9 +
 dist/compiler/CompilerResult.d.ts             |     7 +
 dist/compiler/CompilerResult.js               |     1 +
 dist/compiler/FileResult.d.ts                 |     6 +
 dist/compiler/FileResult.js                   |     1 +
 dist/compiler/default_config.d.ts             |     3 +
 dist/compiler/default_config.js               |    11 +
 dist/compiler/transformers.d.ts               |     8 +
 dist/compiler/transformers.js                 |    13 +
 .../FunctionDeclarationTransformer.d.ts       |     7 +
 .../FunctionDeclarationTransformer.js         |    47 +
 .../HasStatementsTransformer.d.ts             |     8 +
 .../transformers/HasStatementsTransformer.js  |    57 +
 dist/compiler/transformers/Transformer.d.ts   |    16 +
 dist/compiler/transformers/Transformer.js     |    39 +
 .../transformers/TransformerConfig.d.ts       |     6 +
 .../transformers/TransformerConfig.js         |     1 +
 .../VariableDeclarationTransformer.d.ts       |    12 +
 .../VariableDeclarationTransformer.js         |    80 +
 .../compiler/transformers/default_config.d.ts |     3 +
 dist/compiler/transformers/default_config.js  |     8 +
 .../transformers/default_transformers.d.ts    |     3 +
 .../transformers/default_transformers.js      |     7 +
 dist/compiler/utils.d.ts                      |     2 +
 dist/compiler/utils.js                        |     3 +
 dist/compiler/utils/generator.d.ts            |     4 +
 dist/compiler/utils/generator.js              |    67 +
 dist/config.d.ts                              |     2 +
 dist/config.js                                |     3 +
 dist/config/Config.d.ts                       |     9 +
 dist/config/Config.js                         |     4 +
 dist/config/default_config.d.ts               |     3 +
 dist/config/default_config.js                 |    10 +
 dist/index.d.ts                               |     1 +
 dist/index.js                                 |     5 +
 dist/lib/r.d.ts                               |     1 +
 dist/lib/r.js                                 |     5 +
 dist/lib/t.d.ts                               |     2 +
 dist/lib/t.js                                 |     4 +
 dist/transform.d.ts                           |     4 +
 dist/transform.js                             |    30 +
 dist/writer.d.ts                              |     4 +
 dist/writer.js                                |     5 +
 dist/writer/Writer.d.ts                       |    10 +
 dist/writer/Writer.js                         |    37 +
 dist/writer/WriterConfig.d.ts                 |     6 +
 dist/writer/WriterConfig.js                   |     1 +
 dist/writer/WriterResult.d.ts                 |     7 +
 dist/writer/WriterResult.js                   |     1 +
 dist/writer/default_config.d.ts               |     3 +
 dist/writer/default_config.js                 |     8 +
 src/bin/index.ts                              |     1 +
 src/bin/status.ts                             |    19 +-
 .../transformers/HasStatementsTransformer.ts  |     6 +-
 .../Development/ts-runtime/src/bus.js         |     1 +
 .../Development/ts-runtime/src/compiler.js    |     6 +
 .../ts-runtime/src/compiler/Compiler.js       |    94 +
 src/playground/index.ts                       |    21 +-
 src/playground/test.js                        |    19 +
 src/playground/test0.js                       | 78660 ++++++++++++++++
 src/playground/test3.js                       |  6555 ++
 src/playground/test4.js                       |     7 +
 src/playground/test4.ts                       |     5 +
 80 files changed, 86336 insertions(+), 17 deletions(-)
 create mode 100644 dist/bin/handlers.d.ts
 create mode 100644 dist/bin/handlers.js
 create mode 100644 dist/bin/index.d.ts
 create mode 100644 dist/bin/index.js
 create mode 100644 dist/bin/status.d.ts
 create mode 100644 dist/bin/status.js
 create mode 100644 dist/bus.d.ts
 create mode 100644 dist/bus.js
 create mode 100644 dist/bus/Bus.d.ts
 create mode 100644 dist/bus/Bus.js
 create mode 100644 dist/compiler.d.ts
 create mode 100644 dist/compiler.js
 create mode 100644 dist/compiler/Compiler.d.ts
 create mode 100644 dist/compiler/Compiler.js
 create mode 100644 dist/compiler/CompilerConfig.d.ts
 create mode 100644 dist/compiler/CompilerConfig.js
 create mode 100644 dist/compiler/CompilerMode.d.ts
 create mode 100644 dist/compiler/CompilerMode.js
 create mode 100644 dist/compiler/CompilerResult.d.ts
 create mode 100644 dist/compiler/CompilerResult.js
 create mode 100644 dist/compiler/FileResult.d.ts
 create mode 100644 dist/compiler/FileResult.js
 create mode 100644 dist/compiler/default_config.d.ts
 create mode 100644 dist/compiler/default_config.js
 create mode 100644 dist/compiler/transformers.d.ts
 create mode 100644 dist/compiler/transformers.js
 create mode 100644 dist/compiler/transformers/FunctionDeclarationTransformer.d.ts
 create mode 100644 dist/compiler/transformers/FunctionDeclarationTransformer.js
 create mode 100644 dist/compiler/transformers/HasStatementsTransformer.d.ts
 create mode 100644 dist/compiler/transformers/HasStatementsTransformer.js
 create mode 100644 dist/compiler/transformers/Transformer.d.ts
 create mode 100644 dist/compiler/transformers/Transformer.js
 create mode 100644 dist/compiler/transformers/TransformerConfig.d.ts
 create mode 100644 dist/compiler/transformers/TransformerConfig.js
 create mode 100644 dist/compiler/transformers/VariableDeclarationTransformer.d.ts
 create mode 100644 dist/compiler/transformers/VariableDeclarationTransformer.js
 create mode 100644 dist/compiler/transformers/default_config.d.ts
 create mode 100644 dist/compiler/transformers/default_config.js
 create mode 100644 dist/compiler/transformers/default_transformers.d.ts
 create mode 100644 dist/compiler/transformers/default_transformers.js
 create mode 100644 dist/compiler/utils.d.ts
 create mode 100644 dist/compiler/utils.js
 create mode 100644 dist/compiler/utils/generator.d.ts
 create mode 100644 dist/compiler/utils/generator.js
 create mode 100644 dist/config.d.ts
 create mode 100644 dist/config.js
 create mode 100644 dist/config/Config.d.ts
 create mode 100644 dist/config/Config.js
 create mode 100644 dist/config/default_config.d.ts
 create mode 100644 dist/config/default_config.js
 create mode 100644 dist/index.d.ts
 create mode 100644 dist/index.js
 create mode 100644 dist/lib/r.d.ts
 create mode 100644 dist/lib/r.js
 create mode 100644 dist/lib/t.d.ts
 create mode 100644 dist/lib/t.js
 create mode 100644 dist/transform.d.ts
 create mode 100644 dist/transform.js
 create mode 100644 dist/writer.d.ts
 create mode 100644 dist/writer.js
 create mode 100644 dist/writer/Writer.d.ts
 create mode 100644 dist/writer/Writer.js
 create mode 100644 dist/writer/WriterConfig.d.ts
 create mode 100644 dist/writer/WriterConfig.js
 create mode 100644 dist/writer/WriterResult.d.ts
 create mode 100644 dist/writer/WriterResult.js
 create mode 100644 dist/writer/default_config.d.ts
 create mode 100644 dist/writer/default_config.js
 create mode 100644 src/playground/Users/fabian/Documents/Development/ts-runtime/src/bus.js
 create mode 100644 src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler.js
 create mode 100644 src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler/Compiler.js
 create mode 100644 src/playground/test.js
 create mode 100644 src/playground/test0.js
 create mode 100644 src/playground/test3.js
 create mode 100644 src/playground/test4.js
 create mode 100644 src/playground/test4.ts

diff --git a/dist/bin/handlers.d.ts b/dist/bin/handlers.d.ts
new file mode 100644
index 0000000..e69de29
diff --git a/dist/bin/handlers.js b/dist/bin/handlers.js
new file mode 100644
index 0000000..c8f9f22
--- /dev/null
+++ b/dist/bin/handlers.js
@@ -0,0 +1,50 @@
+"use strict";
+const cp = require("child_process");
+const path = require("path");
+const bus_1 = require("../bus");
+const child = cp.fork(path.join(__dirname, './status'));
+child.send({ message: 'init' });
+child.on('exit', () => {
+    process.exit();
+});
+function handleError(error) {
+    child.send({ message: 'error', payload: error });
+}
+process.on('uncaughtException', handleError);
+process.on('unhandledRejection', handleError);
+bus_1.bus.on('error', handleError);
+bus_1.bus.on('main.start', (filePaths) => {
+    child.send({ message: 'start', payload: filePaths.length });
+});
+bus_1.bus.on('main.done', (filePaths) => {
+    child.send({ message: 'end' });
+});
+bus_1.bus.on('transform.file.start', (filePath) => {
+    child.send({ message: 'fileStart', payload: filePath });
+});
+bus_1.bus.on('transform.file.readError', (filePath) => {
+    child.send({ message: 'fileReadError', payload: filePath });
+});
+bus_1.bus.on('transform.file.done', (filePath) => {
+    child.send({ message: 'fileEnd', payload: filePath });
+});
+bus_1.bus.on('write.start', (num) => {
+    child.send({ message: 'writeStart', payload: num });
+});
+bus_1.bus.on('write.end', (num) => {
+    child.send({ message: 'writeEnd', payload: num });
+});
+bus_1.bus.on('write.file.start', (filePath) => {
+    child.send({ message: 'fileWriteStart', payload: filePath });
+});
+bus_1.bus.on('transform.file.done', (filePath) => {
+    child.send({ message: 'fileWriteEnd', payload: filePath });
+});
+// process.on('SIGINT', () => {
+//   child.send({message: 'term'});
+// });
+//
+// process.on('SIGTERM', () => {
+//   process.stdin.resume();
+//   child.send({message: 'term'});
+// });
diff --git a/dist/bin/index.d.ts b/dist/bin/index.d.ts
new file mode 100644
index 0000000..637118d
--- /dev/null
+++ b/dist/bin/index.d.ts
@@ -0,0 +1 @@
+import './handlers';
diff --git a/dist/bin/index.js b/dist/bin/index.js
new file mode 100644
index 0000000..dfd4388
--- /dev/null
+++ b/dist/bin/index.js
@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+"use strict";
+require("./handlers");
+const program = require("commander");
+const transform_1 = require("../transform");
+const writer_1 = require("../writer");
+const pkg = require('../../package.json');
+const config = {};
+const writerConfig = writer_1.DEFAULT_CONFIG;
+let write = false;
+function defaultAction() {
+    const files = program.args.filter((value) => {
+        return typeof value === 'string';
+    });
+    transform_1.default(files)
+        .then((compilerResult) => {
+        if (write) {
+            const writer = new writer_1.Writer(compilerResult);
+            writer.writeAll();
+        }
+    });
+}
+function setNoAssertConst() {
+    config.assertConst = true;
+}
+function setEncoding(encoding) {
+    config.encoding = encoding;
+    writerConfig.encoding = encoding;
+}
+function setWrite(location, base) {
+    write = true;
+    writerConfig.writePath = location || writerConfig.writePath;
+    writerConfig.basePath = base || writerConfig.basePath;
+}
+program
+    .version(pkg.version)
+    .description(`---------  ts-runtime  ---------
+  Inserts runtime type checks and
+  emits pretty printed TypeScript.
+  --------------------------------`)
+    .usage('[options] <file ...>')
+    .option('-w, --write', 'persist files', setWrite)
+    .option('-e, --encoding <encoding>', 'set file encoding. defaults to utf8', setEncoding)
+    .option('--no-assert-const', 'turn off const declaration checks.', setNoAssertConst)
+    .on('--help', () => {
+    console.log('  Examples:');
+    console.log();
+    console.log('    $ tsr --no-assert-const file.ts');
+    console.log('    $ tsr --write ./out ./src ./src/file1.ts ./src/file2.ts');
+    console.log();
+});
+program.parse(process.argv);
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}
+else {
+    defaultAction();
+}
diff --git a/dist/bin/status.d.ts b/dist/bin/status.d.ts
new file mode 100644
index 0000000..e69de29
diff --git a/dist/bin/status.js b/dist/bin/status.js
new file mode 100644
index 0000000..984cfb3
--- /dev/null
+++ b/dist/bin/status.js
@@ -0,0 +1,98 @@
+"use strict";
+const path = require("path");
+const ora = require("ora");
+const chalk = require("chalk");
+const symbols = require("log-symbols");
+let spinner;
+let fileCount = 0;
+let processed = 0;
+let errors = 0;
+process.on('uncaughtException', (error) => {
+    status.error(error);
+});
+process.on('unhandledRejection', (reason, p) => {
+    status.error(new Error(reason));
+});
+process.on('SIGINT', () => {
+    status.term();
+    process.exit();
+});
+process.on('SIGTERM', () => {
+    status.term();
+    process.exit();
+});
+process.on('message', (data) => {
+    if (typeof status[data.message] === 'function') {
+        status[data.message](data.payload);
+    }
+});
+const status = {};
+status.init = () => {
+    spinner = null;
+    fileCount = 0;
+    processed = 0;
+    errors = 0;
+    spinner = ora();
+};
+status.start = (num) => {
+    fileCount = num;
+    spinner.text = chalk.bold(`Got ${num} file${num === 1 ? '' : 's'} to process:`);
+    spinner.stopAndPersist();
+    spinner.text = `${processed}/${fileCount}`;
+    spinner.start();
+    return spinner;
+};
+status.end = () => {
+    if (errors > 0) {
+        spinner.stopAndPersist({ symbol: symbols.warning, text: chalk.yellow(`All processing finished, but there ${errors === 1 ? 'was' : 'were'} ${errors} error${errors === 1 ? '' : 's'}`) });
+    }
+    else {
+        spinner.succeed(chalk.green('All files have been processed'));
+    }
+    process.exit(0);
+};
+status.term = () => {
+    spinner.fail(chalk.red('Processing was interrupted'));
+};
+status.fileStart = (filePath) => {
+    processed++;
+    const countStr = chalk.gray(`[${processed}/${fileCount}]`);
+    spinner.text = `${countStr} Processing ${path.basename(filePath)}`;
+};
+status.fileEnd = (filePath) => {
+    const countStr = chalk.gray(`[${processed}/${fileCount}]`);
+    spinner.succeed(`${countStr} Done processing ${path.basename(filePath)}`);
+    spinner.start();
+};
+status.fileFail = (filePath) => {
+    errors++;
+    const countStr = chalk.gray(`[${processed}/${fileCount}]`);
+    spinner.fail(`${countStr} Error processing ${path.basename(filePath)}`);
+    spinner.start();
+};
+status.fileReadError = (filePath) => {
+    errors++;
+    const countStr = chalk.gray(`[${processed}/${fileCount}]`);
+    spinner.fail(`${countStr} Could not read ${path.basename(filePath)}`);
+    spinner.start();
+};
+status.writeStart = (num) => {
+    spinner.text = `Writing files`;
+};
+status.writeEnd = (num) => {
+    spinner.succeed(`Wrote ${num} files`);
+};
+status.fileWriteStart = (filePath) => {
+};
+status.fileWriteEnd = (filePath) => {
+};
+status.error = (err) => {
+    errors++;
+    if (typeof err === 'string') {
+        spinner.fail(chalk.red(err));
+    }
+    if (err instanceof Error) {
+        spinner.fail(chalk.red(err.message));
+    }
+    process.exit();
+};
diff --git a/dist/bus.d.ts b/dist/bus.d.ts
new file mode 100644
index 0000000..6ec1e45
--- /dev/null
+++ b/dist/bus.d.ts
@@ -0,0 +1 @@
+export { EventBus, bus } from './bus/Bus';
diff --git a/dist/bus.js b/dist/bus.js
new file mode 100644
index 0000000..ead0d45
--- /dev/null
+++ b/dist/bus.js
@@ -0,0 +1,4 @@
+"use strict";
+var Bus_1 = require("./bus/Bus");
+exports.EventBus = Bus_1.EventBus;
+exports.bus = Bus_1.bus;
diff --git a/dist/bus/Bus.d.ts b/dist/bus/Bus.d.ts
new file mode 100644
index 0000000..b1b0032
--- /dev/null
+++ b/dist/bus/Bus.d.ts
@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import * as EventEmitter from 'events';
+export declare class EventBus extends EventEmitter {
+}
+export declare const bus: EventBus;
+export default bus;
diff --git a/dist/bus/Bus.js b/dist/bus/Bus.js
new file mode 100644
index 0000000..5f35bcc
--- /dev/null
+++ b/dist/bus/Bus.js
@@ -0,0 +1,8 @@
+"use strict";
+const EventEmitter = require("events");
+class EventBus extends EventEmitter {
+}
+exports.EventBus = EventBus;
+exports.bus = new EventBus();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.bus;
diff --git a/dist/compiler.d.ts b/dist/compiler.d.ts
new file mode 100644
index 0000000..27992e1
--- /dev/null
+++ b/dist/compiler.d.ts
@@ -0,0 +1,6 @@
+export { FileResult } from './compiler/FileResult';
+export { Compiler } from './compiler/Compiler';
+export { CompilerResult } from './compiler/CompilerResult';
+export { CompilerMode } from './compiler/CompilerMode';
+export { CompilerConfig } from './compiler/CompilerConfig';
+export { DEFAULT_CONFIG } from './compiler/default_config';
diff --git a/dist/compiler.js b/dist/compiler.js
new file mode 100644
index 0000000..0c3c0a2
--- /dev/null
+++ b/dist/compiler.js
@@ -0,0 +1,7 @@
+"use strict";
+var Compiler_1 = require("./compiler/Compiler");
+exports.Compiler = Compiler_1.Compiler;
+var CompilerMode_1 = require("./compiler/CompilerMode");
+exports.CompilerMode = CompilerMode_1.CompilerMode;
+var default_config_1 = require("./compiler/default_config");
+exports.DEFAULT_CONFIG = default_config_1.DEFAULT_CONFIG;
diff --git a/dist/compiler/Compiler.d.ts b/dist/compiler/Compiler.d.ts
new file mode 100644
index 0000000..e026531
--- /dev/null
+++ b/dist/compiler/Compiler.d.ts
@@ -0,0 +1,16 @@
+import * as ts from 'typescript';
+import { Config } from '../config';
+import { Transformer } from './transformers';
+import CompilerResult from './CompilerResult';
+export declare class Compiler {
+    protected config: Config;
+    protected transformers: Transformer[];
+    constructor(config: Config, transformers?: Transformer[]);
+    process(): Promise<CompilerResult>;
+    protected onSubstituteNode(context: ts.EmitContext, node: ts.Node): ts.Node;
+    private transformFile(filePath, transformers);
+    private visit(node);
+    private visitChildrenFirst(node);
+    private visitParentFirst(node);
+}
+export default Compiler;
diff --git a/dist/compiler/Compiler.js b/dist/compiler/Compiler.js
new file mode 100644
index 0000000..4e4a0a5
--- /dev/null
+++ b/dist/compiler/Compiler.js
@@ -0,0 +1,95 @@
+"use strict";
+// import * as fs from 'fs';
+const path = require("path");
+const ts = require("typescript");
+const transformers_1 = require("./transformers");
+const bus_1 = require("../bus");
+const CompilerMode_1 = require("./CompilerMode");
+class Compiler {
+    constructor(config, transformers) {
+        this.config = config;
+        this.transformers = [];
+        const transformersToEnable = transformers || transformers_1.DEFAULT_TRANSFORMERS;
+        transformers_1.Transformer.DEFAULT_CONFIG = config;
+        const enabledTtransformers = Object.keys(transformersToEnable)
+            .map((key) => {
+            return transformers ?
+                transformers[key] :
+                new transformersToEnable[key]();
+        });
+        this.transformers.push(...enabledTtransformers);
+    }
+    process() {
+        bus_1.bus.emit('compiler.start', this.config);
+        const toTransform = [];
+        const transform = (context) => (sourceFile) => {
+            context.onSubstituteNode = this.onSubstituteNode.bind(this);
+            for (const transformer of this.transformers) {
+                for (const substitution of transformer.getSubstitutions()) {
+                    context.enableSubstitution(substitution);
+                }
+            }
+            return sourceFile;
+        };
+        for (const file of this.config.files) {
+            toTransform.push(this.transformFile(file, [transform]));
+        }
+        // Do not reject this promise, if individual files fail
+        return Promise.all(toTransform.map(p => p.catch(e => e)))
+            .then(results => {
+            bus_1.bus.emit('compiler.done', this.config);
+            return {
+                config: this.config,
+                fileResults: results,
+            };
+        });
+    }
+    onSubstituteNode(context, node) {
+        let substitutedNode = node;
+        let parent = node.parent;
+        for (const transformer of this.transformers) {
+            substitutedNode = transformer.process(substitutedNode, context);
+        }
+        return substitutedNode;
+    }
+    transformFile(filePath, transformers) {
+        bus_1.bus.emit('transform.file.start', filePath);
+        return new Promise((resolve, reject) => {
+            filePath = path.normalize(path.join(process.cwd(), filePath));
+            const fileName = path.basename(filePath);
+            const source = ts.sys.readFile(filePath, this.config.encoding);
+            if (source === undefined) {
+                bus_1.bus.emit('transform.file.readError', filePath);
+                return reject(`Error reading ${filePath}`);
+            }
+            let sourceFile = ts.createSourceFile(fileName, source, this.config.languageVersion || ts.ScriptTarget.Latest, this.config.setParentNodes || true, this.config.scriptKind || ts.ScriptKind.TS);
+            if (this.config.mode === CompilerMode_1.default.Visit) {
+                transformers = [];
+                sourceFile = this.visit(sourceFile);
+            }
+            const result = ts.emit(sourceFile, transformers).result;
+            bus_1.bus.emit('transform.file.done', filePath);
+            resolve({
+                fileName,
+                filePath,
+                result,
+            });
+        });
+    }
+    visit(node) {
+        return this.config.visitChildrenFirst ?
+            this.visitChildrenFirst(node) :
+            this.visitParentFirst(node);
+    }
+    visitChildrenFirst(node) {
+        node = ts.visitEachChild(node, this.visitChildrenFirst.bind(this));
+        return this.onSubstituteNode(undefined, node);
+    }
+    visitParentFirst(node) {
+        node = this.onSubstituteNode(undefined, node);
+        return ts.visitEachChild(node, this.visitParentFirst.bind(this));
+    }
+}
+exports.Compiler = Compiler;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Compiler;
diff --git a/dist/compiler/CompilerConfig.d.ts b/dist/compiler/CompilerConfig.d.ts
new file mode 100644
index 0000000..7ce0aac
--- /dev/null
+++ b/dist/compiler/CompilerConfig.d.ts
@@ -0,0 +1,9 @@
+import CompilerMode from './CompilerMode';
+import TransformerConfig from './transformers/TransformerConfig';
+export interface CompilerConfig extends TransformerConfig {
+    files?: string[];
+    encoding?: string;
+    mode?: CompilerMode;
+    visitChildrenFirst?: boolean;
+}
+export default CompilerConfig;
diff --git a/dist/compiler/CompilerConfig.js b/dist/compiler/CompilerConfig.js
new file mode 100644
index 0000000..3918c74
--- /dev/null
+++ b/dist/compiler/CompilerConfig.js
@@ -0,0 +1 @@
+"use strict";
diff --git a/dist/compiler/CompilerMode.d.ts b/dist/compiler/CompilerMode.d.ts
new file mode 100644
index 0000000..1f9608a
--- /dev/null
+++ b/dist/compiler/CompilerMode.d.ts
@@ -0,0 +1,5 @@
+export declare enum CompilerMode {
+    Substitute = 1,
+    Visit = 2,
+}
+export default CompilerMode;
diff --git a/dist/compiler/CompilerMode.js b/dist/compiler/CompilerMode.js
new file mode 100644
index 0000000..6abbfcd
--- /dev/null
+++ b/dist/compiler/CompilerMode.js
@@ -0,0 +1,9 @@
+"use strict";
+(function (CompilerMode) {
+    CompilerMode[CompilerMode["Substitute"] = 1] = "Substitute";
+    CompilerMode[CompilerMode["Visit"] = 2] = "Visit";
+})(exports.CompilerMode || (exports.CompilerMode = {}));
+var CompilerMode = exports.CompilerMode;
+;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = CompilerMode;
diff --git a/dist/compiler/CompilerResult.d.ts b/dist/compiler/CompilerResult.d.ts
new file mode 100644
index 0000000..b880e24
--- /dev/null
+++ b/dist/compiler/CompilerResult.d.ts
@@ -0,0 +1,7 @@
+import FileResult from './FileResult';
+import { Config } from '../config';
+export interface CompilerResult {
+    config: Config;
+    fileResults: FileResult[];
+}
+export default CompilerResult;
diff --git a/dist/compiler/CompilerResult.js b/dist/compiler/CompilerResult.js
new file mode 100644
index 0000000..3918c74
--- /dev/null
+++ b/dist/compiler/CompilerResult.js
@@ -0,0 +1 @@
+"use strict";
diff --git a/dist/compiler/FileResult.d.ts b/dist/compiler/FileResult.d.ts
new file mode 100644
index 0000000..d12c004
--- /dev/null
+++ b/dist/compiler/FileResult.d.ts
@@ -0,0 +1,6 @@
+export interface FileResult {
+    result: string;
+    filePath: string;
+    fileName: string;
+}
+export default FileResult;
diff --git a/dist/compiler/FileResult.js b/dist/compiler/FileResult.js
new file mode 100644
index 0000000..3918c74
--- /dev/null
+++ b/dist/compiler/FileResult.js
@@ -0,0 +1 @@
+"use strict";
diff --git a/dist/compiler/default_config.d.ts b/dist/compiler/default_config.d.ts
new file mode 100644
index 0000000..461370e
--- /dev/null
+++ b/dist/compiler/default_config.d.ts
@@ -0,0 +1,3 @@
+import CompilerConfig from './CompilerConfig';
+export declare const DEFAULT_CONFIG: CompilerConfig;
+export default DEFAULT_CONFIG;
diff --git a/dist/compiler/default_config.js b/dist/compiler/default_config.js
new file mode 100644
index 0000000..a0e18b9
--- /dev/null
+++ b/dist/compiler/default_config.js
@@ -0,0 +1,11 @@
+"use strict";
+const default_config_1 = require("./transformers/default_config");
+const CompilerMode_1 = require("./CompilerMode");
+exports.DEFAULT_CONFIG = Object.assign({}, {
+    files: [],
+    encoding: 'utf8',
+    mode: CompilerMode_1.default.Substitute,
+    visitChildrenFirst: false,
+}, default_config_1.default);
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.DEFAULT_CONFIG;
diff --git a/dist/compiler/transformers.d.ts b/dist/compiler/transformers.d.ts
new file mode 100644
index 0000000..bbe8236
--- /dev/null
+++ b/dist/compiler/transformers.d.ts
@@ -0,0 +1,8 @@
+export { Transformer } from './transformers/Transformer';
+export { VariableDeclarationTransformer } from './transformers/VariableDeclarationTransformer';
+export { FunctionDeclarationTransformer } from './transformers/FunctionDeclarationTransformer';
+export { HasStatementsTransformer } from './transformers/HasStatementsTransformer';
+export { TransformerConfig } from './transformers/TransformerConfig';
+import * as DEFAULT_TRANSFORMERS from './transformers/default_transformers';
+export { DEFAULT_TRANSFORMERS };
+export { DEFAULT_CONFIG } from './transformers/default_config';
diff --git a/dist/compiler/transformers.js b/dist/compiler/transformers.js
new file mode 100644
index 0000000..c401611
--- /dev/null
+++ b/dist/compiler/transformers.js
@@ -0,0 +1,13 @@
+"use strict";
+var Transformer_1 = require("./transformers/Transformer");
+exports.Transformer = Transformer_1.Transformer;
+var VariableDeclarationTransformer_1 = require("./transformers/VariableDeclarationTransformer");
+exports.VariableDeclarationTransformer = VariableDeclarationTransformer_1.VariableDeclarationTransformer;
+var FunctionDeclarationTransformer_1 = require("./transformers/FunctionDeclarationTransformer");
+exports.FunctionDeclarationTransformer = FunctionDeclarationTransformer_1.FunctionDeclarationTransformer;
+var HasStatementsTransformer_1 = require("./transformers/HasStatementsTransformer");
+exports.HasStatementsTransformer = HasStatementsTransformer_1.HasStatementsTransformer;
+const DEFAULT_TRANSFORMERS = require("./transformers/default_transformers");
+exports.DEFAULT_TRANSFORMERS = DEFAULT_TRANSFORMERS;
+var default_config_1 = require("./transformers/default_config");
+exports.DEFAULT_CONFIG = default_config_1.DEFAULT_CONFIG;
diff --git a/dist/compiler/transformers/FunctionDeclarationTransformer.d.ts b/dist/compiler/transformers/FunctionDeclarationTransformer.d.ts
new file mode 100644
index 0000000..4b5b398
--- /dev/null
+++ b/dist/compiler/transformers/FunctionDeclarationTransformer.d.ts
@@ -0,0 +1,7 @@
+import * as ts from 'typescript';
+import { Transformer } from './Transformer';
+export declare class FunctionDeclarationTransformer extends Transformer {
+    protected substitution: ts.SyntaxKind;
+    protected transform(node: ts.FunctionDeclaration, context: ts.EmitContext): ts.Node;
+}
+export default FunctionDeclarationTransformer;
diff --git a/dist/compiler/transformers/FunctionDeclarationTransformer.js b/dist/compiler/transformers/FunctionDeclarationTransformer.js
new file mode 100644
index 0000000..bbca161
--- /dev/null
+++ b/dist/compiler/transformers/FunctionDeclarationTransformer.js
@@ -0,0 +1,47 @@
+"use strict";
+const ts = require("typescript");
+const Transformer_1 = require("./Transformer");
+const utils_1 = require("../utils");
+class FunctionDeclarationTransformer extends Transformer_1.Transformer {
+    constructor() {
+        super(...arguments);
+        this.substitution = ts.SyntaxKind.FunctionDeclaration;
+    }
+    transform(node, context) {
+        const typeDefinitions = [];
+        const typeChecks = [];
+        if (!node.parameters) {
+            return node;
+        }
+        for (const param of node.parameters) {
+            if (param.type === undefined) {
+                continue;
+            }
+            const paramName = param.name.getText();
+            const typeDefinition = utils_1.generator.createTypeDefinition(param.type, `_${paramName}Type`);
+            const typeCheck = ts.factory.createStatement(ts.factory.createCall(ts.factory.createPropertyAccess(ts.factory.createCall(ts.factory.createPropertyAccess(ts.factory.createIdentifier('t'), ts.factory.createIdentifier('param')), [], [
+                ts.factory.createLiteral(paramName),
+                ts.factory.createIdentifier(`_${paramName}Type`),
+                param.questionToken === undefined ? ts.factory.createLiteral(false) : ts.factory.createLiteral(true),
+            ]), ts.factory.createIdentifier('assert')), [], [ts.factory.createIdentifier(paramName)]));
+            ts.factory.createStatement(utils_1.generator.createTypeCall(`_${paramName}Type`, 'assert', [ts.factory.createIdentifier(paramName)]));
+            typeDefinitions.push(typeDefinition);
+            typeChecks.push(typeCheck);
+        }
+        let returnTypeDefinition = [];
+        let returnTypeCheck = [];
+        if (node.type !== undefined) {
+            returnTypeDefinition.push(ts.factory.createVariableStatement([], ts.factory.createVariableDeclarationList([
+                ts.factory.createVariableDeclaration('_returnType', undefined, ts.factory.createCall(ts.factory.createPropertyAccess(ts.factory.createIdentifier('t'), ts.factory.createIdentifier('return')), [], [utils_1.generator.createTypeCalls(node.type)])),
+            ], undefined, ts.NodeFlags.Const)));
+        }
+        const paramList = ts.factory.createVariableStatement([], ts.factory.createVariableDeclarationList(typeDefinitions, undefined, ts.NodeFlags.Let));
+        const body = node.body;
+        body.statements.unshift(paramList, ...returnTypeDefinition, ...typeChecks);
+        const updatedNode = ts.factory.updateFunctionDeclaration(node, node.decorators, node.modifiers, node.name, node.typeParameters, node.parameters, node.type, body);
+        return updatedNode;
+    }
+}
+exports.FunctionDeclarationTransformer = FunctionDeclarationTransformer;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = FunctionDeclarationTransformer;
diff --git a/dist/compiler/transformers/HasStatementsTransformer.d.ts b/dist/compiler/transformers/HasStatementsTransformer.d.ts
new file mode 100644
index 0000000..6cee40c
--- /dev/null
+++ b/dist/compiler/transformers/HasStatementsTransformer.d.ts
@@ -0,0 +1,8 @@
+import * as ts from 'typescript';
+import Transformer from './Transformer';
+export declare class HasStatementsTransformer extends Transformer {
+    protected substitution: ts.SyntaxKind[];
+    protected transform(node: ts.SourceFile | ts.Block | ts.ModuleBlock | ts.CaseClause | ts.DefaultClause): ts.Node;
+    private createFunctionAnnotation(node);
+}
+export default HasStatementsTransformer;
diff --git a/dist/compiler/transformers/HasStatementsTransformer.js b/dist/compiler/transformers/HasStatementsTransformer.js
new file mode 100644
index 0000000..69f6a10
--- /dev/null
+++ b/dist/compiler/transformers/HasStatementsTransformer.js
@@ -0,0 +1,57 @@
+"use strict";
+const ts = require("typescript");
+const Transformer_1 = require("./Transformer");
+const utils_1 = require("../utils");
+// type HasStatementsNode = ts.SourceFile | ts.Block | ts.ModuleBlock | ts.CaseClause | ts.DefaultClause;
+// export { HasStatementsNode };
+class HasStatementsTransformer extends Transformer_1.default {
+    constructor() {
+        super(...arguments);
+        this.substitution = [
+            ts.SyntaxKind.SourceFile,
+            ts.SyntaxKind.Block,
+            ts.SyntaxKind.ModuleBlock,
+            ts.SyntaxKind.CaseClause,
+            ts.SyntaxKind.DefaultClause,
+        ];
+    }
+    transform(node) {
+        if (!Array.isArray(node.statements)) {
+            return node;
+        }
+        const statements = node.statements;
+        let i = 0;
+        for (const statement of node.statements) {
+            if (statement.kind !== ts.SyntaxKind.FunctionDeclaration) {
+                continue;
+            }
+            const annotation = this.createFunctionAnnotation(statement);
+            statements.splice(++i, 0, annotation);
+        }
+        node.statements = statements;
+        return node;
+    }
+    createFunctionAnnotation(node) {
+        const returnType = node.type;
+        const args = [];
+        for (const param of node.parameters) {
+            args.push(ts.factory.createCall(ts.factory.createPropertyAccess(ts.factory.createIdentifier('t'), ts.factory.createIdentifier('param')), [], [
+                ts.factory.createLiteral(param.name.getText()),
+                utils_1.generator.createTypeCalls(param.type),
+            ]));
+        }
+        if (node.type !== undefined) {
+            args.push(ts.factory.createCall(ts.factory.createPropertyAccess(ts.factory.createIdentifier('t'), ts.factory.createIdentifier('return')), [], [
+                utils_1.generator.createTypeCalls(node.type),
+            ]));
+        }
+        const annotation = ts.factory.createStatement(ts.factory.createCall(ts.factory.createPropertyAccess(ts.factory.createIdentifier('t'), ts.factory.createIdentifier('annotate')), [], [
+            ts.factory.createIdentifier(node.name.getText()),
+            ts.factory.createCall(ts.factory.createPropertyAccess(ts.factory.createIdentifier('t'), ts.factory.createIdentifier('function')), [], args),
+        ]));
+        return annotation;
+    }
+}
+exports.HasStatementsTransformer = HasStatementsTransformer;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = HasStatementsTransformer;
diff --git a/dist/compiler/transformers/Transformer.d.ts b/dist/compiler/transformers/Transformer.d.ts
new file mode 100644
index 0000000..1abedbe
--- /dev/null
+++ b/dist/compiler/transformers/Transformer.d.ts
@@ -0,0 +1,16 @@
+import * as ts from 'typescript';
+import { Config } from '../../config';
+export declare abstract class Transformer {
+    static DEFAULT_CONFIG: Config;
+    protected config: Config;
+    protected visited: ts.Node[];
+    protected abstract substitution: ts.SyntaxKind | ts.SyntaxKind[];
+    protected abstract transform(node: ts.Node, context?: ts.EmitContext): ts.Node;
+    constructor(config?: Config);
+    getSubstitutions(): ts.SyntaxKind[];
+    getVisited(): ts.Node[];
+    process(node: ts.Node, context?: ts.EmitContext): ts.Node;
+    protected wasGenerated(node: ts.Node): boolean;
+    protected wasVisited(node: ts.Node): boolean;
+}
+export default Transformer;
diff --git a/dist/compiler/transformers/Transformer.js b/dist/compiler/transformers/Transformer.js
new file mode 100644
index 0000000..2688bc8
--- /dev/null
+++ b/dist/compiler/transformers/Transformer.js
@@ -0,0 +1,39 @@
+"use strict";
+const config_1 = require("../../config");
+class Transformer {
+    constructor(config) {
+        this.visited = [];
+        this.config = config ? config : Transformer.DEFAULT_CONFIG;
+    }
+    getSubstitutions() {
+        return !Array.isArray(this.substitution) ? [this.substitution] : this.substitution;
+    }
+    getVisited() {
+        return this.visited;
+    }
+    process(node, context) {
+        if (this.config.skipGenerated && this.wasGenerated(node)) {
+            return node;
+        }
+        if (this.config.skipVisited) {
+            if (this.wasVisited(node)) {
+                return node;
+            }
+            this.visited.push(node);
+        }
+        if (this.getSubstitutions().indexOf(node.kind) === -1) {
+            return node;
+        }
+        return this.transform(node, context);
+    }
+    wasGenerated(node) {
+        return !node.parent;
+    }
+    wasVisited(node) {
+        return this.visited.indexOf(node) !== -1;
+    }
+}
+exports.Transformer = Transformer;
+Transformer.DEFAULT_CONFIG = config_1.DEFAULT_CONFIG;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Transformer;
diff --git a/dist/compiler/transformers/TransformerConfig.d.ts b/dist/compiler/transformers/TransformerConfig.d.ts
new file mode 100644
index 0000000..3b14034
--- /dev/null
+++ b/dist/compiler/transformers/TransformerConfig.d.ts
@@ -0,0 +1,6 @@
+export interface TransformerConfig {
+    skipVisited?: boolean;
+    skipGenerated?: boolean;
+    assertConst?: boolean;
+}
+export default TransformerConfig;
diff --git a/dist/compiler/transformers/TransformerConfig.js b/dist/compiler/transformers/TransformerConfig.js
new file mode 100644
index 0000000..3918c74
--- /dev/null
+++ b/dist/compiler/transformers/TransformerConfig.js
@@ -0,0 +1 @@
+"use strict";
diff --git a/dist/compiler/transformers/VariableDeclarationTransformer.d.ts b/dist/compiler/transformers/VariableDeclarationTransformer.d.ts
new file mode 100644
index 0000000..deb6d82
--- /dev/null
+++ b/dist/compiler/transformers/VariableDeclarationTransformer.d.ts
@@ -0,0 +1,12 @@
+import * as ts from 'typescript';
+import { Transformer } from './Transformer';
+export declare class VariableDeclarationTransformer extends Transformer {
+    protected substitution: ts.SyntaxKind;
+    protected transform(node: ts.VariableDeclarationList): ts.Node;
+    private transformDeclaration(node);
+    private transformLetDeclaration(node);
+    private transformConstDeclaration(node);
+    private transformUntypedLetDeclaration(node);
+    private transformUntypedConstDeclaration(node);
+}
+export default VariableDeclarationTransformer;
diff --git a/dist/compiler/transformers/VariableDeclarationTransformer.js b/dist/compiler/transformers/VariableDeclarationTransformer.js
new file mode 100644
index 0000000..bde8152
--- /dev/null
+++ b/dist/compiler/transformers/VariableDeclarationTransformer.js
@@ -0,0 +1,80 @@
+"use strict";
+const ts = require("typescript");
+const Transformer_1 = require("./Transformer");
+const utils_1 = require("../utils");
+class VariableDeclarationTransformer extends Transformer_1.Transformer {
+    constructor() {
+        super(...arguments);
+        this.substitution = ts.SyntaxKind.VariableDeclarationList;
+    }
+    transform(node) {
+        const declarations = [];
+        if (!node.declarations) {
+            return node;
+        }
+        for (const declaration of node.declarations) {
+            if (declaration.initializer)
+                if (declaration.kind === ts.SyntaxKind.VariableDeclaration) {
+                    declarations.push(...this.transformDeclaration(declaration));
+                    continue;
+                }
+            declarations.push(declaration);
+        }
+        return ts.factory.updateVariableDeclarationList(node, declarations);
+    }
+    transformDeclaration(node) {
+        if (this.wasGenerated(node)) {
+            return [node];
+        }
+        if (!node.type) {
+            if (node.parent.flags === ts.NodeFlags.Const) {
+                return this.transformUntypedConstDeclaration(node);
+            }
+            return this.transformUntypedLetDeclaration(node);
+        }
+        if (node.parent.flags === ts.NodeFlags.Const) {
+            return this.transformConstDeclaration(node);
+        }
+        return this.transformLetDeclaration(node);
+    }
+    transformLetDeclaration(node) {
+        const nodeName = node.name.getText();
+        const typeDefinition = utils_1.generator.createTypeDefinition(node.type, `_${nodeName}Type`);
+        if (!node.initializer) {
+            return [typeDefinition, node];
+        }
+        const initializer = utils_1.generator.createTypeCall(`_${nodeName}Type`, 'assert', [node.initializer]);
+        const assignment = ts.factory.updateVariableDeclaration(node, node.name, node.type, initializer);
+        return [typeDefinition, assignment];
+    }
+    transformConstDeclaration(node) {
+        const nodeName = node.name.getText();
+        const typeCalls = utils_1.generator.createTypeCalls(node.type);
+        const initializer = ts.factory.createCall(ts.factory.createPropertyAccess(typeCalls, 'assert'), [], [node.initializer]);
+        const assignment = ts.factory.updateVariableDeclaration(node, node.name, node.type, initializer);
+        return [assignment];
+    }
+    transformUntypedLetDeclaration(node) {
+        const nodeName = node.name.getText();
+        const typeDefinition = utils_1.generator.createTypeDefinition('any', `_${nodeName}Type`);
+        if (!node.initializer) {
+            return [typeDefinition, node];
+        }
+        const initializer = utils_1.generator.createTypeCall(`_${nodeName}Type`, 'assert', [node.initializer]);
+        const assignment = ts.factory.updateVariableDeclaration(node, node.name, node.type, initializer);
+        return [typeDefinition, assignment];
+    }
+    transformUntypedConstDeclaration(node) {
+        if (!this.config.assertConst) {
+            return [node];
+        }
+        const nodeName = node.name.getText();
+        const typeCalls = utils_1.generator.createTypeCall('t', 'any');
+        const initializer = ts.factory.createCall(ts.factory.createPropertyAccess(typeCalls, 'assert'), [], [node.initializer]);
+        const assignment = ts.factory.updateVariableDeclaration(node, node.name, node.type, initializer);
+        return [assignment];
+    }
+}
+exports.VariableDeclarationTransformer = VariableDeclarationTransformer;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = VariableDeclarationTransformer;
diff --git a/dist/compiler/transformers/default_config.d.ts b/dist/compiler/transformers/default_config.d.ts
new file mode 100644
index 0000000..f7d80de
--- /dev/null
+++ b/dist/compiler/transformers/default_config.d.ts
@@ -0,0 +1,3 @@
+import TransformerConfig from './TransformerConfig';
+export declare const DEFAULT_CONFIG: TransformerConfig;
+export default DEFAULT_CONFIG;
diff --git a/dist/compiler/transformers/default_config.js b/dist/compiler/transformers/default_config.js
new file mode 100644
index 0000000..995aa78
--- /dev/null
+++ b/dist/compiler/transformers/default_config.js
@@ -0,0 +1,8 @@
+"use strict";
+exports.DEFAULT_CONFIG = {
+    skipVisited: true,
+    skipGenerated: true,
+    assertConst: true,
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.DEFAULT_CONFIG;
diff --git a/dist/compiler/transformers/default_transformers.d.ts b/dist/compiler/transformers/default_transformers.d.ts
new file mode 100644
index 0000000..17d936d
--- /dev/null
+++ b/dist/compiler/transformers/default_transformers.d.ts
@@ -0,0 +1,3 @@
+export { FunctionDeclarationTransformer } from './FunctionDeclarationTransformer';
+export { HasStatementsTransformer } from './HasStatementsTransformer';
+export { VariableDeclarationTransformer } from './VariableDeclarationTransformer';
diff --git a/dist/compiler/transformers/default_transformers.js b/dist/compiler/transformers/default_transformers.js
new file mode 100644
index 0000000..3a61e3e
--- /dev/null
+++ b/dist/compiler/transformers/default_transformers.js
@@ -0,0 +1,7 @@
+"use strict";
+var FunctionDeclarationTransformer_1 = require("./FunctionDeclarationTransformer");
+exports.FunctionDeclarationTransformer = FunctionDeclarationTransformer_1.FunctionDeclarationTransformer;
+var HasStatementsTransformer_1 = require("./HasStatementsTransformer");
+exports.HasStatementsTransformer = HasStatementsTransformer_1.HasStatementsTransformer;
+var VariableDeclarationTransformer_1 = require("./VariableDeclarationTransformer");
+exports.VariableDeclarationTransformer = VariableDeclarationTransformer_1.VariableDeclarationTransformer;
diff --git a/dist/compiler/utils.d.ts b/dist/compiler/utils.d.ts
new file mode 100644
index 0000000..7cb583f
--- /dev/null
+++ b/dist/compiler/utils.d.ts
@@ -0,0 +1,2 @@
+import * as generator from './utils/generator';
+export { generator };
diff --git a/dist/compiler/utils.js b/dist/compiler/utils.js
new file mode 100644
index 0000000..fbe5b72
--- /dev/null
+++ b/dist/compiler/utils.js
@@ -0,0 +1,3 @@
+"use strict";
+const generator = require("./utils/generator");
+exports.generator = generator;
diff --git a/dist/compiler/utils/generator.d.ts b/dist/compiler/utils/generator.d.ts
new file mode 100644
index 0000000..f207e2b
--- /dev/null
+++ b/dist/compiler/utils/generator.d.ts
@@ -0,0 +1,4 @@
+import * as ts from 'typescript';
+export declare function createTypeDefinition(type: ts.TypeNode | string, name: string): ts.VariableDeclaration;
+export declare function createTypeCalls(type: ts.TypeNode | string): ts.CallExpression;
+export declare function createTypeCall(id: string, prop: string, args?: ts.Expression[], types?: ts.TypeNode[]): ts.CallExpression;
diff --git a/dist/compiler/utils/generator.js b/dist/compiler/utils/generator.js
new file mode 100644
index 0000000..8379984
--- /dev/null
+++ b/dist/compiler/utils/generator.js
@@ -0,0 +1,67 @@
+"use strict";
+const ts = require("typescript");
+function createTypeDefinition(type, name) {
+    return ts.factory.createVariableDeclaration(name, undefined, createTypeCalls(type));
+}
+exports.createTypeDefinition = createTypeDefinition;
+function createTypeCalls(type) {
+    if (!type) {
+        return null;
+    }
+    if (typeof type === 'string') {
+        return createTypeCall('t', type);
+    }
+    type = type;
+    switch (type.kind) {
+        case ts.SyntaxKind.BooleanKeyword:
+        case ts.SyntaxKind.NumberKeyword:
+        case ts.SyntaxKind.StringKeyword:
+        case ts.SyntaxKind.AnyKeyword:
+            {
+                return createTypeCall('t', type.getText());
+            }
+        case ts.SyntaxKind.ArrayType:
+            {
+                const typeNode = type.elementType;
+                const callExpression = createTypeCall('t', 'array', [createTypeCalls(typeNode)]);
+                return callExpression;
+            }
+        case ts.SyntaxKind.TypeReference:
+            {
+                const typeRef = type;
+                const typeName = typeRef.typeName.getText();
+                const args = [];
+                let callExpression;
+                if (typeRef.typeArguments) {
+                    for (const arg of typeRef.typeArguments) {
+                        args.push(createTypeCalls(arg));
+                    }
+                }
+                if (typeName === 'Array' || typeName === 'array') {
+                    callExpression = createTypeCall('t', 'array', args);
+                }
+                else {
+                    callExpression = createTypeCall('t', 'ref', [ts.factory.createIdentifier(typeName)]);
+                }
+                return callExpression;
+            }
+        case ts.SyntaxKind.TupleType:
+            {
+                const typeRef = type;
+                const args = [];
+                for (const arg of typeRef.elementTypes) {
+                    args.push(createTypeCalls(arg));
+                }
+                return createTypeCall('t', 'tuple', args);
+            }
+        default:
+            {
+                return createTypeCall('t', 'any');
+            }
+    }
+}
+exports.createTypeCalls = createTypeCalls;
+function createTypeCall(id, prop, args = [], types = []) {
+    return ts.factory.createCall(ts.factory.createPropertyAccess(ts.factory.createIdentifier(id), prop), types, args);
+}
+exports.createTypeCall = createTypeCall;
diff --git a/dist/config.d.ts b/dist/config.d.ts
new file mode 100644
index 0000000..3cfced7
--- /dev/null
+++ b/dist/config.d.ts
@@ -0,0 +1,2 @@
+export { Config } from './config/Config';
+export { DEFAULT_CONFIG } from './config/default_config';
diff --git a/dist/config.js b/dist/config.js
new file mode 100644
index 0000000..7a00f68
--- /dev/null
+++ b/dist/config.js
@@ -0,0 +1,3 @@
+"use strict";
+var default_config_1 = require("./config/default_config");
+exports.DEFAULT_CONFIG = default_config_1.DEFAULT_CONFIG;
diff --git a/dist/config/Config.d.ts b/dist/config/Config.d.ts
new file mode 100644
index 0000000..c0ca664
--- /dev/null
+++ b/dist/config/Config.d.ts
@@ -0,0 +1,9 @@
+import { ScriptTarget, ScriptKind } from 'typescript';
+import { CompilerConfig } from '../compiler/CompilerConfig';
+export interface Config extends CompilerConfig {
+    languageVersion?: ScriptTarget;
+    scriptKind?: ScriptKind;
+    setParentNodes?: boolean;
+}
+export { ScriptTarget, ScriptKind };
+export default Config;
diff --git a/dist/config/Config.js b/dist/config/Config.js
new file mode 100644
index 0000000..7893d40
--- /dev/null
+++ b/dist/config/Config.js
@@ -0,0 +1,4 @@
+"use strict";
+const typescript_1 = require("typescript");
+exports.ScriptTarget = typescript_1.ScriptTarget;
+exports.ScriptKind = typescript_1.ScriptKind;
diff --git a/dist/config/default_config.d.ts b/dist/config/default_config.d.ts
new file mode 100644
index 0000000..d51a799
--- /dev/null
+++ b/dist/config/default_config.d.ts
@@ -0,0 +1,3 @@
+import { Config } from './Config';
+export declare const DEFAULT_CONFIG: Config;
+export default DEFAULT_CONFIG;
diff --git a/dist/config/default_config.js b/dist/config/default_config.js
new file mode 100644
index 0000000..9a75027
--- /dev/null
+++ b/dist/config/default_config.js
@@ -0,0 +1,10 @@
+"use strict";
+const Config_1 = require("./Config");
+const default_config_1 = require("../compiler/default_config");
+exports.DEFAULT_CONFIG = Object.assign({}, {
+    languageVersion: Config_1.ScriptTarget.ES6,
+    scriptKind: Config_1.ScriptKind.TS,
+    setParentNodes: true,
+}, default_config_1.default);
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.DEFAULT_CONFIG;
diff --git a/dist/index.d.ts b/dist/index.d.ts
new file mode 100644
index 0000000..d5e7ab1
--- /dev/null
+++ b/dist/index.d.ts
@@ -0,0 +1 @@
+export * from './transform';
diff --git a/dist/index.js b/dist/index.js
new file mode 100644
index 0000000..3521300
--- /dev/null
+++ b/dist/index.js
@@ -0,0 +1,5 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+__export(require("./transform"));
diff --git a/dist/lib/r.d.ts b/dist/lib/r.d.ts
new file mode 100644
index 0000000..aa2f40f
--- /dev/null
+++ b/dist/lib/r.d.ts
@@ -0,0 +1 @@
+export declare function getType(): void;
diff --git a/dist/lib/r.js b/dist/lib/r.js
new file mode 100644
index 0000000..94de928
--- /dev/null
+++ b/dist/lib/r.js
@@ -0,0 +1,5 @@
+"use strict";
+function getType() {
+    // returns either the parameter or t.ref(parameter);
+}
+exports.getType = getType;
diff --git a/dist/lib/t.d.ts b/dist/lib/t.d.ts
new file mode 100644
index 0000000..8f39e0f
--- /dev/null
+++ b/dist/lib/t.d.ts
@@ -0,0 +1,2 @@
+import t from 'flow-runtime';
+export default t;
diff --git a/dist/lib/t.js b/dist/lib/t.js
new file mode 100644
index 0000000..3b25338
--- /dev/null
+++ b/dist/lib/t.js
@@ -0,0 +1,4 @@
+"use strict";
+const flow_runtime_1 = require("flow-runtime");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = flow_runtime_1.default;
diff --git a/dist/transform.d.ts b/dist/transform.d.ts
new file mode 100644
index 0000000..36e1363
--- /dev/null
+++ b/dist/transform.d.ts
@@ -0,0 +1,4 @@
+import { CompilerResult } from './compiler';
+import { Config } from './config';
+export declare function transform(files?: string | string[], config?: Config): Promise<CompilerResult>;
+export default transform;
diff --git a/dist/transform.js b/dist/transform.js
new file mode 100644
index 0000000..c782945
--- /dev/null
+++ b/dist/transform.js
@@ -0,0 +1,30 @@
+"use strict";
+const compiler_1 = require("./compiler");
+const config_1 = require("./config");
+const bus_1 = require("./bus");
+function transform(files, config = {}) {
+    config = getConfig(config);
+    config.files = getFiles(files || config.files);
+    bus_1.bus.emit('main.start', config.files);
+    return new compiler_1.Compiler(config)
+        .process()
+        .then(transformerResult => {
+        bus_1.bus.emit('main.done', config.files);
+        return transformerResult;
+    });
+}
+exports.transform = transform;
+function getConfig(config = {}) {
+    return Object.assign({}, config_1.DEFAULT_CONFIG, config);
+}
+function getFiles(files) {
+    if (typeof files === 'string') {
+        files = [files];
+    }
+    if (!Array.isArray(files)) {
+        bus_1.bus.emit('error', new TypeError('Files passed to transform must be of type string[] or string.'));
+    }
+    return files;
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = transform;
diff --git a/dist/writer.d.ts b/dist/writer.d.ts
new file mode 100644
index 0000000..405f801
--- /dev/null
+++ b/dist/writer.d.ts
@@ -0,0 +1,4 @@
+export { Writer } from './writer/Writer';
+export { WriterConfig } from './writer/WriterConfig';
+export { WriterResult } from './writer/WriterResult';
+export { DEFAULT_CONFIG } from './writer/default_config';
diff --git a/dist/writer.js b/dist/writer.js
new file mode 100644
index 0000000..b97038e
--- /dev/null
+++ b/dist/writer.js
@@ -0,0 +1,5 @@
+"use strict";
+var Writer_1 = require("./writer/Writer");
+exports.Writer = Writer_1.Writer;
+var default_config_1 = require("./writer/default_config");
+exports.DEFAULT_CONFIG = default_config_1.DEFAULT_CONFIG;
diff --git a/dist/writer/Writer.d.ts b/dist/writer/Writer.d.ts
new file mode 100644
index 0000000..5c1be3b
--- /dev/null
+++ b/dist/writer/Writer.d.ts
@@ -0,0 +1,10 @@
+import { CompilerResult, FileResult } from '../compiler';
+import WriterConfig from './WriterConfig';
+import WriterResult from './WriterResult';
+export declare class Writer {
+    private transformerResult;
+    constructor(transformerResult: CompilerResult);
+    writeAll(config?: WriterConfig): Promise<WriterResult[]>;
+    writeFile(fileResult: FileResult, config?: WriterConfig): Promise<WriterResult>;
+}
+export default Writer;
diff --git a/dist/writer/Writer.js b/dist/writer/Writer.js
new file mode 100644
index 0000000..960244d
--- /dev/null
+++ b/dist/writer/Writer.js
@@ -0,0 +1,37 @@
+"use strict";
+const path = require("path");
+// import * as fs from 'fs';
+const ts = require("typescript");
+const default_config_1 = require("./default_config");
+const bus_1 = require("../bus");
+class Writer {
+    constructor(transformerResult) {
+        this.transformerResult = transformerResult;
+    }
+    writeAll(config) {
+        const toWrite = [];
+        for (const fileResult of this.transformerResult.fileResults) {
+            toWrite.push(this.writeFile(fileResult, config));
+        }
+        return Promise.all(toWrite);
+    }
+    writeFile(fileResult, config) {
+        return new Promise((resolve, reject) => {
+            config = config ? Object.assign({}, default_config_1.default, config) : default_config_1.default;
+            const file = fileResult.filePath.replace(new RegExp(`^${config.basePath}`), '');
+            let location = path.join(config.writePath, file);
+            location = path.join(path.dirname(path.join(config.writePath, file)), `${path.basename(location, '.ts')}.js`);
+            ts.sys.writeFile(location, fileResult.result);
+            bus_1.bus.emit('write.file.done', fileResult.filePath);
+            resolve({
+                fileResult,
+                originalPath: fileResult.fileName,
+                writePath: location,
+            });
+            bus_1.bus.emit('write.file.start', fileResult.filePath);
+        });
+    }
+}
+exports.Writer = Writer;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Writer;
diff --git a/dist/writer/WriterConfig.d.ts b/dist/writer/WriterConfig.d.ts
new file mode 100644
index 0000000..8bd3409
--- /dev/null
+++ b/dist/writer/WriterConfig.d.ts
@@ -0,0 +1,6 @@
+export interface WriterConfig {
+    basePath: string;
+    writePath: string;
+    encoding?: string;
+}
+export default WriterConfig;
diff --git a/dist/writer/WriterConfig.js b/dist/writer/WriterConfig.js
new file mode 100644
index 0000000..3918c74
--- /dev/null
+++ b/dist/writer/WriterConfig.js
@@ -0,0 +1 @@
+"use strict";
diff --git a/dist/writer/WriterResult.d.ts b/dist/writer/WriterResult.d.ts
new file mode 100644
index 0000000..86d8cc5
--- /dev/null
+++ b/dist/writer/WriterResult.d.ts
@@ -0,0 +1,7 @@
+import { FileResult } from '../compiler';
+export interface WriterResult {
+    fileResult: FileResult;
+    originalPath: string;
+    writePath: string;
+}
+export default WriterResult;
diff --git a/dist/writer/WriterResult.js b/dist/writer/WriterResult.js
new file mode 100644
index 0000000..3918c74
--- /dev/null
+++ b/dist/writer/WriterResult.js
@@ -0,0 +1 @@
+"use strict";
diff --git a/dist/writer/default_config.d.ts b/dist/writer/default_config.d.ts
new file mode 100644
index 0000000..afc5203
--- /dev/null
+++ b/dist/writer/default_config.d.ts
@@ -0,0 +1,3 @@
+import WriterConfig from './WriterConfig';
+export declare const DEFAULT_CONFIG: WriterConfig;
+export default DEFAULT_CONFIG;
diff --git a/dist/writer/default_config.js b/dist/writer/default_config.js
new file mode 100644
index 0000000..b4e70f1
--- /dev/null
+++ b/dist/writer/default_config.js
@@ -0,0 +1,8 @@
+"use strict";
+exports.DEFAULT_CONFIG = {
+    basePath: process.cwd(),
+    writePath: process.cwd(),
+    encoding: 'utf8',
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.DEFAULT_CONFIG;
diff --git a/src/bin/index.ts b/src/bin/index.ts
index fee0b92..e4d5630 100644
--- a/src/bin/index.ts
+++ b/src/bin/index.ts
@@ -65,6 +65,7 @@ program.parse(process.argv);
 
 if (!process.argv.slice(2).length) {
   program.outputHelp();
+  process.exit();
 } else {
   defaultAction();
 }
diff --git a/src/bin/status.ts b/src/bin/status.ts
index effa330..18f7b25 100644
--- a/src/bin/status.ts
+++ b/src/bin/status.ts
@@ -7,6 +7,8 @@ let spinner: any;
 let fileCount: number = 0;
 let processed: number = 0;
 let errors: number = 0;
+let startWrite: number = 0;
+let written: number = 0;
 
 process.on('uncaughtException', (error: Error) => {
   status.error(error);
@@ -39,6 +41,8 @@ status.init = () => {
   fileCount = 0;
   processed = 0;
   errors = 0;
+  startWrite = 0;
+  written = 0;
   spinner = ora();
 };
 
@@ -53,11 +57,20 @@ status.start = (num: number) => {
 
 status.end = () => {
   if (errors > 0) {
-    spinner.stopAndPersist({symbol: symbols.warning, text: chalk.yellow(`All processing finished, but there ${errors === 1 ? 'was' : 'were'} ${errors} error${errors === 1 ? '' : 's'}`)});
+    const text = chalk.yellow(`Processing finished, but there ${errors === 1 ? 'was' : 'were'} ${errors} error${errors === 1 ? '' : 's'}`);
+    spinner.stopAndPersist({ symbol: symbols.warning, text });
   } else {
     spinner.succeed(chalk.green('All files have been processed'));
   }
 
+  if (written < startWrite) {
+    const noFinish = startWrite - written;
+    const text = chalk.yellow(`${written} file${written === 1 ? '' : 's'} ${written === 1 ? 'has' : 'have'} been written, ${noFinish} did not finish`);
+    spinner.stopAndPersist({ symbol: symbols.warning, text });
+  } else if (written > 0) {
+    spinner.succeed(chalk.green(`${written} file${written === 1 ? '' : 's'} ${written === 1 ? 'has' : 'have'} been written`));
+  }
+
   process.exit(0);
 };
 
@@ -100,11 +113,11 @@ status.writeEnd = (num: number) => {
 };
 
 status.fileWriteStart = (filePath: string) => {
-
+  startWrite++;
 };
 
 status.fileWriteEnd = (filePath: string) => {
-
+  written++;
 };
 
 status.error = (err: any) => {
diff --git a/src/compiler/transformers/HasStatementsTransformer.ts b/src/compiler/transformers/HasStatementsTransformer.ts
index b7d12d2..fe01f8f 100644
--- a/src/compiler/transformers/HasStatementsTransformer.ts
+++ b/src/compiler/transformers/HasStatementsTransformer.ts
@@ -2,8 +2,8 @@ import * as ts from 'typescript';
 import Transformer from './Transformer';
 import { generator } from '../utils';
 
-type HasStatementsNode = ts.SourceFile | ts.Block | ts.ModuleBlock | ts.CaseClause | ts.DefaultClause;
-export { HasStatementsNode };
+// type HasStatementsNode = ts.SourceFile | ts.Block | ts.ModuleBlock | ts.CaseClause | ts.DefaultClause;
+// export { HasStatementsNode };
 
 export class HasStatementsTransformer extends Transformer {
 
@@ -15,7 +15,7 @@ export class HasStatementsTransformer extends Transformer {
     ts.SyntaxKind.DefaultClause,
   ];
 
-  protected transform(node: HasStatementsNode): ts.Node {
+  protected transform(node: ts.SourceFile | ts.Block | ts.ModuleBlock | ts.CaseClause | ts.DefaultClause): ts.Node {
     if (!Array.isArray(node.statements)) {
       return node;
     }
diff --git a/src/playground/Users/fabian/Documents/Development/ts-runtime/src/bus.js b/src/playground/Users/fabian/Documents/Development/ts-runtime/src/bus.js
new file mode 100644
index 0000000..6ec1e45
--- /dev/null
+++ b/src/playground/Users/fabian/Documents/Development/ts-runtime/src/bus.js
@@ -0,0 +1 @@
+export { EventBus, bus } from './bus/Bus';
diff --git a/src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler.js b/src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler.js
new file mode 100644
index 0000000..27992e1
--- /dev/null
+++ b/src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler.js
@@ -0,0 +1,6 @@
+export { FileResult } from './compiler/FileResult';
+export { Compiler } from './compiler/Compiler';
+export { CompilerResult } from './compiler/CompilerResult';
+export { CompilerMode } from './compiler/CompilerMode';
+export { CompilerConfig } from './compiler/CompilerConfig';
+export { DEFAULT_CONFIG } from './compiler/default_config';
diff --git a/src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler/Compiler.js b/src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler/Compiler.js
new file mode 100644
index 0000000..f8cf8d1
--- /dev/null
+++ b/src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler/Compiler.js
@@ -0,0 +1,94 @@
+// import * as fs from 'fs';
+import * as path from 'path';
+import * as ts from 'typescript';
+import { Config } from '../config';
+import { Transformer, DEFAULT_TRANSFORMERS } from './transformers';
+import { bus } from '../bus';
+import CompilerMode from './CompilerMode';
+import CompilerResult from './CompilerResult';
+import FileResult from './FileResult';
+export class Compiler {
+    protected transformers: Transformer[] = [];
+    constructor(protected config: Config, transformers?: Transformer[]) {
+        const transformersToEnable = t.any().assert(transformers || DEFAULT_TRANSFORMERS);
+        Transformer.DEFAULT_CONFIG = config;
+        const enabledTtransformers = t.any().assert(Object.keys(transformersToEnable)
+            .map((key: string) => {
+            return transformers ?
+                (transformers as any)[key] as Transformer :
+                new (transformersToEnable as any)[key]() as Transformer;
+        }));
+        this.transformers.push(...enabledTtransformers);
+    }
+    public process(): Promise<CompilerResult> {
+        bus.emit('compiler.start', this.config);
+        const toTransform = t.array(t.ref(Promise)).assert([]);
+        const transform = t.ref(ts.Transformer).assert((context) => (sourceFile) => {
+            context.onSubstituteNode = this.onSubstituteNode.bind(this);
+            for (const transformer of this.transformers) {
+                for (const substitution of transformer.getSubstitutions()) {
+                    context.enableSubstitution(substitution);
+                }
+            }
+            return sourceFile;
+        });
+        for (const file of this.config.files) {
+            toTransform.push(this.transformFile(file, [transform]));
+        }
+        // Do not reject this promise, if individual files fail
+        return Promise.all(toTransform.map(p => p.catch(e => e)))
+            .then(results => {
+            bus.emit('compiler.done', this.config);
+            return {
+                config: this.config,
+                fileResults: results
+            };
+        });
+    }
+    protected onSubstituteNode(context: ts.EmitContext, node: ts.Node): ts.Node {
+        let _substitutedNodeType = t.any(), substitutedNode = _substitutedNodeType.assert(node);
+        let _parentType = t.any(), parent = _parentType.assert(node.parent);
+        for (const transformer of this.transformers) {
+            substitutedNode = transformer.process(substitutedNode, context);
+        }
+        return substitutedNode;
+    }
+    private transformFile(filePath: string, transformers: ts.Transformer[]): Promise<FileResult> {
+        bus.emit('transform.file.start', filePath);
+        return new Promise((resolve, reject) => {
+            filePath = path.normalize(path.join(process.cwd(), filePath));
+            const fileName = t.any().assert(path.basename(filePath));
+            const source = t.any().assert(ts.sys.readFile(filePath, this.config.encoding));
+            if (source === undefined) {
+                bus.emit('transform.file.readError', filePath);
+                return reject("Error reading "filePath"");
+            }
+            let _sourceFileType = t.any(), sourceFile = _sourceFileType.assert(ts.createSourceFile(fileName, source, this.config.languageVersion || ts.ScriptTarget.Latest, this.config.setParentNodes || true, this.config.scriptKind || ts.ScriptKind.TS));
+            if (this.config.mode === CompilerMode.Visit) {
+                transformers = [];
+                sourceFile = this.visit(sourceFile) as ts.SourceFile;
+            }
+            const result = t.any().assert(ts.emit(sourceFile, transformers).result);
+            bus.emit('transform.file.done', filePath);
+            resolve({
+                fileName,
+                filePath,
+                result
+            });
+        });
+    }
+    private visit(node: ts.Node): ts.Node {
+        return this.config.visitChildrenFirst ?
+            this.visitChildrenFirst(node) :
+            this.visitParentFirst(node);
+    }
+    private visitChildrenFirst(node: ts.Node): ts.Node {
+        node = ts.visitEachChild(node, this.visitChildrenFirst.bind(this));
+        return this.onSubstituteNode(undefined, node);
+    }
+    private visitParentFirst(node: ts.Node): ts.Node {
+        node = this.onSubstituteNode(undefined, node);
+        return ts.visitEachChild(node, this.visitParentFirst.bind(this));
+    }
+}
+export default Compiler;
diff --git a/src/playground/index.ts b/src/playground/index.ts
index 36aae9b..b28ce4d 100644
--- a/src/playground/index.ts
+++ b/src/playground/index.ts
@@ -1,19 +1,18 @@
 import * as path from 'path';
 import * as tsr from '../index';
 import { Config } from '../config';
-// import { Writer, WriterConfig } from '../writer';
+import { Writer, WriterConfig } from '../writer';
 
-const file1 = path.join(__dirname, 'test1.ts');
-const file2 = path.join(__dirname, 'test.ts');
+const file1 = path.join('test1.ts');
+const file2 = path.join('test.ts');
 
 // const writerConfig: WriterConfig = {
-//   basePath: __dirname,
-//   writePath: __dirname,
+//   // basePath: __dirname,
+//   // writePath: __dirname,
 // };
 
-tsr.transform([file1, file2]);
-
-// .then(compilerResult => {
-//   const writer = new Writer(compilerResult);
-//   writer.writeAll(writerConfig);
-// });
+tsr.transform([file1, file2])
+.then(compilerResult => {
+  const writer = new Writer(compilerResult);
+  writer.writeAll();
+});
diff --git a/src/playground/test.js b/src/playground/test.js
new file mode 100644
index 0000000..bb5aeec
--- /dev/null
+++ b/src/playground/test.js
@@ -0,0 +1,19 @@
+class A {
+}
+function f(param1: boolean, param2?: string[]): string {
+    let _param1Type = t.boolean(), _param2Type = t.array(t.string());
+    const _returnType = t.return(t.string());
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let _xType = t.ref(ComplexType), x = _xType.assert(() => {
+        const a = t.boolean().assert(true);
+        return a;
+    });
+    const b = t.number().assert(10);
+    let c;
+    let _dType = t.array(t.boolean()), d = _dType.assert([true, false]);
+    const e = t.array(t.array(t.array(t.number()))).assert([[[10]]]);
+    c = 'hi';
+    let f;
+    return c;
+}
diff --git a/src/playground/test0.js b/src/playground/test0.js
new file mode 100644
index 0000000..ce5a646
--- /dev/null
+++ b/src/playground/test0.js
@@ -0,0 +1,78660 @@
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
diff --git a/src/playground/test3.js b/src/playground/test3.js
new file mode 100644
index 0000000..afca512
--- /dev/null
+++ b/src/playground/test3.js
@@ -0,0 +1,6555 @@
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
+function test(param1: string, param2?: boolean[]): [number, string] {
+    let _param1Type = t.string(), _param2Type = t.array(t.boolean());
+    const _returnType = t.return(t.tuple(t.number(), t.string()));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let another;
+    const num = t.number().assert(10);
+    let _strType = t.string(), str = _strType.assert('hi');
+    var _bbType = t.ref(Object), bb = _bbType.assert({});
+    let u; // use any type
+    let _xType = t.any(), x = _xType.assert(10); // TODO: use implicit type
+    const y = t.any().assert('hi');
+    x = 1; // TODO: check reassignments
+    return [num, str]; // TODO: check return value
+}
+let g;
+let _eType = t.any(), e = _eType.assert(g = 10);
+g = 'hi';
+g = 10;
diff --git a/src/playground/test4.js b/src/playground/test4.js
new file mode 100644
index 0000000..dcb0050
--- /dev/null
+++ b/src/playground/test4.js
@@ -0,0 +1,7 @@
+import { Test } from './test';
+function a(param1: string, param2?: Test[]) {
+    let _param1Type = t.string(), _param2Type = t.array(t.ref(Test));
+    t.param("param1", _param1Type, false).assert(param1);
+    t.param("param2", _param2Type, true).assert(param2);
+    let _somethingType = t.boolean(), something = _somethingType.assert(getNumber());
+}
diff --git a/src/playground/test4.ts b/src/playground/test4.ts
new file mode 100644
index 0000000..84506a1
--- /dev/null
+++ b/src/playground/test4.ts
@@ -0,0 +1,5 @@
+import { Test } from './test';
+
+function a(param1: string: param2?: Test[]) {
+  let something: boolean = getNumber();
+}

From f8f5ca17021e465000d71d5c221a4c4287acb325 Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Tue, 14 Mar 2017 22:02:55 +0100
Subject: [PATCH 02/26] Transition to the official transformer API.

---
 package.json                                  |   6 +-
 src/next/bus.ts                               |  28 +++
 src/next/context.ts                           | 100 +++++++++
 src/next/index.ts                             |   5 +
 src/next/mutators.ts                          |  11 +
 src/next/mutators/IdentifierMutator.ts        |  21 ++
 src/next/mutators/ImportSpecifierMutator.ts   |  15 ++
 .../mutators/InterfaceDeclararionMutator.ts   |  35 +++
 src/next/mutators/Mutator.ts                  |  35 +++
 src/next/options.ts                           |  17 ++
 src/next/transform.ts                         | 204 ++++++++++++++++++
 tslint.json                                   |   5 +-
 yarn.lock                                     |  77 ++++++-
 13 files changed, 551 insertions(+), 8 deletions(-)
 create mode 100644 src/next/bus.ts
 create mode 100644 src/next/context.ts
 create mode 100644 src/next/index.ts
 create mode 100644 src/next/mutators.ts
 create mode 100644 src/next/mutators/IdentifierMutator.ts
 create mode 100644 src/next/mutators/ImportSpecifierMutator.ts
 create mode 100644 src/next/mutators/InterfaceDeclararionMutator.ts
 create mode 100644 src/next/mutators/Mutator.ts
 create mode 100644 src/next/options.ts
 create mode 100644 src/next/transform.ts

diff --git a/package.json b/package.json
index f1b4150..33a002e 100644
--- a/package.json
+++ b/package.json
@@ -21,13 +21,15 @@
     "log-symbols": "^1.0.2",
     "node-status": "^1.0.0",
     "ora": "^1.1.0",
+    "rimraf": "^2.6.1",
     "ts-type-info": "^6.2.2",
-    "typescript": "Microsoft/TypeScript#6c122bcf16c329a21da04d7b5256f20ecc0bbd1d"
+    "typescript": "next"
   },
   "devDependencies": {
     "@types/commander": "^2.3.31",
     "@types/escodegen": "^0.0.6",
     "@types/esprima": "^2.1.33",
-    "@types/node": "^7.0.2"
+    "@types/node": "^7.0.2",
+    "@types/rimraf": "^0.0.28"
   }
 }
diff --git a/src/next/bus.ts b/src/next/bus.ts
new file mode 100644
index 0000000..602cfbd
--- /dev/null
+++ b/src/next/bus.ts
@@ -0,0 +1,28 @@
+import * as EventEmitter from 'events';
+
+export const events = {
+  START: Symbol('start'),
+  END: Symbol('end'),
+  DIAGNOSTICS: Symbol('ts.diagnostics'),
+  DIAGNOSTICS_TRANSFORM: Symbol('ts.diagnostics.transform'),
+  DIAGNOSTICS_TRANSFORM_PRE: Symbol('ts.diagnostics.transform.pre'),
+  DIAGNOSTICS_TRANSFORM_POST: Symbol('ts.diagnostics.transform.post'),
+  DIAGNOSTICS_EMIT: Symbol('ts.diagnostics.emit'),
+  DIAGNOSTICS_EMIT_PRE: Symbol('ts.diagnostics.emit.pre'),
+  DIAGNOSTICS_EMIT_POST: Symbol('ts.diagnostics.emit.post'),
+  TRANSFORM_START: Symbol('transform.start'),
+  TRANSFORM_END: Symbol('transform.end'),
+  // TRANSFORM_ERROR: Symbol('transform.error'),
+  WRITE_START: Symbol('write.start'),
+  WRITE_END: Symbol('write.end'),
+  WRITE_FILE_START: Symbol('write.file.start'),
+  WRITE_FILE_END: Symbol('write.file.end'),
+  // WRITE_ERROR: Symbol('write.error'),
+  EMIT_START: Symbol('emit.start'),
+  EMIT_END: Symbol('emit.end'),
+  // EMIT_ERROR: Symbol('emit.error'),
+  TEMP_DELETE_START: Symbol('temp.delete.start'),
+  TEMP_DELETE_END: Symbol('temp.delete.end'),
+};
+
+export const emitter = new EventEmitter();
diff --git a/src/next/context.ts b/src/next/context.ts
new file mode 100644
index 0000000..f9cbf6f
--- /dev/null
+++ b/src/next/context.ts
@@ -0,0 +1,100 @@
+import * as ts from 'typescript';
+
+export type Scope = ts.SourceFile | ts.Block | ts.ModuleBlock | ts.CaseBlock;
+
+export class MutationContext {
+
+  private _sourceFile: ts.SourceFile;
+  private _scope: Scope;
+  private _visited: ts.Node[];
+  private _transformationContext: ts.TransformationContext;
+
+  constructor(sf?: ts.SourceFile) {
+    this._scope = sf;
+    this._visited = [];
+  }
+
+  public wasVisited(node: ts.Node): boolean {
+    if (this._visited.indexOf(node) !== -1) {
+      return true;
+    }
+
+    return false;
+  }
+
+  public addVisited(node: ts.Node, recursive = false): void {
+    if (!this.wasVisited(node)) {
+      this._visited.push(node);
+    }
+
+    if (recursive) {
+      ts.forEachChild(node, (n: ts.Node) => {
+        this.addVisited(n, recursive);
+      });
+    }
+  }
+
+  public removeVisited(node: ts.Node): boolean {
+    const index = this._visited.indexOf(node);
+
+    if (index !== -1) {
+      this._visited.splice(index, 1);
+      return true;
+    }
+
+    return false;
+  }
+
+  public setScope(node: ts.Node): void {
+    this.scope = node;
+  }
+
+  public setTransformationContext(transformationContext: ts.TransformationContext): void {
+    this.transformationContext = transformationContext;
+  }
+
+  public setSourceFile(sourceFile: ts.Node): void {
+    this.sourceFile = sourceFile as ts.SourceFile;
+  }
+
+  get transformationContext() {
+    return this._transformationContext;
+  }
+
+  set transformationContext(transformationContext: ts.TransformationContext) {
+    this._transformationContext = transformationContext;
+  }
+
+  get visited() {
+    return this._visited;
+  }
+
+  get scope() {
+    return this._scope;
+  }
+
+  set scope(node: ts.Node) {
+    switch (node.kind) {
+      case ts.SyntaxKind.SourceFile:
+        this._sourceFile = node as ts.SourceFile;
+      case ts.SyntaxKind.Block:
+      case ts.SyntaxKind.ModuleBlock:
+      case ts.SyntaxKind.CaseBlock:
+        this._scope = node as Scope;
+        break;
+      default:
+      // throw new Error(`Scope must be SourceFile, Block, ModuleBlock or CaseBlock, got ${ts.SyntaxKind[node.kind]}.`);
+    }
+  }
+
+  get sourceFile() {
+    return this._sourceFile;
+  }
+
+  set sourceFile(sourceFile: ts.SourceFile) {
+    if (sourceFile.kind === ts.SyntaxKind.SourceFile) {
+      this._sourceFile = sourceFile;
+    }
+  }
+
+}
diff --git a/src/next/index.ts b/src/next/index.ts
new file mode 100644
index 0000000..4e90cce
--- /dev/null
+++ b/src/next/index.ts
@@ -0,0 +1,5 @@
+export * from './bus';
+export * from './context';
+export * from './mutators';
+export * from './options';
+export * from './transform';
diff --git a/src/next/mutators.ts b/src/next/mutators.ts
new file mode 100644
index 0000000..975aa67
--- /dev/null
+++ b/src/next/mutators.ts
@@ -0,0 +1,11 @@
+import { Mutator } from './mutators/Mutator';
+
+import { IdentifierMutator } from './mutators/IdentifierMutator';
+import { ImportSpecifierMutator } from './mutators/ImportSpecifierMutator';
+import { InterfaceDeclarationMutator } from './mutators/InterfaceDeclararionMutator';
+
+export const mutators: Mutator[] = [
+  new IdentifierMutator(),
+  new ImportSpecifierMutator(),
+  new InterfaceDeclarationMutator()
+];
diff --git a/src/next/mutators/IdentifierMutator.ts b/src/next/mutators/IdentifierMutator.ts
new file mode 100644
index 0000000..93f2be1
--- /dev/null
+++ b/src/next/mutators/IdentifierMutator.ts
@@ -0,0 +1,21 @@
+import * as ts from 'typescript';
+import { Mutator } from './Mutator';
+import { MutationContext } from '../context'
+
+export class IdentifierMutator extends Mutator {
+
+  protected kind = ts.SyntaxKind.Identifier;
+
+  public mutate(node: ts.Identifier, context: MutationContext): ts.Node {
+    // console.log(node.getText());
+    // console.log(node.modifiers);
+    // console.log(node.originalKeywordKind);
+    // console.log(ts.NodeFlags[node.flags]);
+
+    // const flags = ts.getCombinedModifierFlags(node);
+    // console.log(flags);
+
+    return node;
+  }
+
+}
diff --git a/src/next/mutators/ImportSpecifierMutator.ts b/src/next/mutators/ImportSpecifierMutator.ts
new file mode 100644
index 0000000..4a6d0e2
--- /dev/null
+++ b/src/next/mutators/ImportSpecifierMutator.ts
@@ -0,0 +1,15 @@
+import * as ts from 'typescript';
+import { Mutator } from './Mutator';
+import { MutationContext } from '../context'
+
+export class ImportSpecifierMutator extends Mutator {
+
+  protected kind = ts.SyntaxKind.ImportSpecifier;
+
+  public mutate(node: ts.ImportSpecifier, context: MutationContext): ts.Node {
+    // const flags = ts.getCombinedModifierFlags(node);
+    // console.log(flags);
+    return node;
+  }
+
+}
diff --git a/src/next/mutators/InterfaceDeclararionMutator.ts b/src/next/mutators/InterfaceDeclararionMutator.ts
new file mode 100644
index 0000000..7256a13
--- /dev/null
+++ b/src/next/mutators/InterfaceDeclararionMutator.ts
@@ -0,0 +1,35 @@
+import * as ts from 'typescript';
+import { Mutator } from './Mutator';
+import { MutationContext } from '../context'
+
+export class InterfaceDeclarationMutator extends Mutator {
+
+  protected kind = ts.SyntaxKind.InterfaceDeclaration;
+
+  public mutate(node: ts.InterfaceDeclaration, context: MutationContext): ts.Node {
+    const substitution = ts.createVariableStatement(
+      node.modifiers,
+      ts.createVariableDeclarationList(
+        [
+          ts.createVariableDeclaration(
+            node.name,
+            undefined,
+            ts.createCall(
+              ts.createIdentifier('Symbol'),
+              undefined,
+              [
+                ts.createLiteral(node.name)
+              ]
+            )
+          )
+        ],
+        ts.NodeFlags.Const
+      )
+    );
+
+    context.addVisited(substitution, true);
+
+    return substitution;
+  }
+
+}
diff --git a/src/next/mutators/Mutator.ts b/src/next/mutators/Mutator.ts
new file mode 100644
index 0000000..263d779
--- /dev/null
+++ b/src/next/mutators/Mutator.ts
@@ -0,0 +1,35 @@
+import * as ts from 'typescript';
+import { MutationContext } from '../context';
+const self = Mutator;
+
+export abstract class Mutator {
+
+  protected abstract kind: ts.SyntaxKind | ts.SyntaxKind[];
+
+  protected abstract mutate(node: ts.Node, context?: MutationContext): ts.Node;
+
+  public mutateNode(node: ts.Node, context: MutationContext): ts.Node {
+    if (!this.shouldMutate(node.kind)) {
+      return node;
+    }
+
+    return this.mutate(node, context);
+  }
+
+  public getKind(): ts.SyntaxKind[] {
+    if (Array.isArray(this.kind)) {
+      return this.kind;
+    }
+
+    return [this.kind];
+  }
+
+  public shouldMutate(kind: ts.SyntaxKind): boolean {
+    if (this.getKind().indexOf(kind) !== -1) {
+      return true;
+    }
+
+    return false;
+  }
+
+}
diff --git a/src/next/options.ts b/src/next/options.ts
new file mode 100644
index 0000000..cba0e41
--- /dev/null
+++ b/src/next/options.ts
@@ -0,0 +1,17 @@
+import * as ts from 'typescript';
+
+export interface Options {
+  compilerOptions?: ts.CompilerOptions;
+  keepTempFiles?: boolean;
+  tempFolderName?: string;
+}
+
+export const defaultOptions: Options = {
+  compilerOptions: {
+    skipLibCheck: true,
+    module: ts.ModuleKind.ES2015,
+    target: ts.ScriptTarget.ES2015
+  },
+  keepTempFiles: true,
+  tempFolderName: '.tsr'
+};
diff --git a/src/next/transform.ts b/src/next/transform.ts
new file mode 100644
index 0000000..0f035bb
--- /dev/null
+++ b/src/next/transform.ts
@@ -0,0 +1,204 @@
+import * as path from 'path';
+import * as rimraf from 'rimraf';
+import * as ts from 'typescript';
+import * as bus from './bus';
+import { MutationContext } from './context';
+import { mutators } from './mutators';
+import { Options, defaultOptions } from './options';
+
+const DEBUG = true;
+
+export function transform(entryFile: string, options?: Options): void {
+  options = getOptions(options);
+  bus.emitter.emit(bus.events.START, { entryFile, options });
+
+  const basePath = path.dirname(entryFile);
+  const host = ts.createCompilerHost(options.compilerOptions);
+  const program = ts.createProgram([entryFile], options.compilerOptions, host);
+
+  const diagnostics: ts.Diagnostic[] = [];
+
+  diagnostics.push(...program.getOptionsDiagnostics());
+  diagnostics.push(...program.getGlobalDiagnostics());
+
+  for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) {
+    diagnostics.push(...program.getSyntacticDiagnostics(sourceFile));
+    diagnostics.push(...program.getSemanticDiagnostics(sourceFile));
+  }
+
+  if (!check(diagnostics)) {
+    bus.emitter.emit(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics });
+    bus.emitter.emit(bus.events.DIAGNOSTICS_TRANSFORM_PRE, { diagnostics });
+  }
+
+  const sourceFiles = program.getSourceFiles().filter(sf => !sf.isDeclarationFile);
+
+  bus.emitter.emit(bus.events.TRANSFORM_START, { sourceFiles });
+  const result = ts.transform(sourceFiles, [transformer], options.compilerOptions);
+  bus.emitter.emit(bus.events.TRANSFORM_END, { sourceFiles: result.transformed });
+
+  if (!check(result.diagnostics)) {
+    bus.emitter.emit(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics });
+    bus.emitter.emit(bus.events.DIAGNOSTICS_TRANSFORM_POST, { diagnostics: result.diagnostics });
+  }
+
+  const printerOptions: ts.PrinterOptions = {
+    target: options.compilerOptions.target,
+    removeComments: false
+  };
+
+  const printHandlers: ts.PrintHandlers = {
+    substituteNode(hint: ts.EmitHint, node: ts.Node): ts.Node {
+      return node;
+    }
+  };
+
+  bus.emitter.emit(bus.events.WRITE_START, { count: result.transformed.length });
+  const printer = ts.createPrinter(printerOptions, printHandlers);
+
+  let count = 0;
+  for (let transformed of result.transformed) {
+    count++;
+    const location = toTempFilePath(transformed.fileName, basePath, options.tempFolderName);
+    const source = printer.printFile(transformed);
+    bus.emitter.emit(bus.events.WRITE_FILE_START, { location, transformed, source });
+    ts.sys.writeFile(location, source);
+    bus.emitter.emit(bus.events.WRITE_FILE_END, { location, transformed, source });
+  }
+
+  bus.emitter.emit(bus.events.WRITE_END, { count });
+  result.dispose();
+
+  emit(entryFile, options);
+
+  if (!options.keepTempFiles) {
+    const tempPath = getTempPath(basePath, options.tempFolderName);
+    bus.emitter.emit(bus.events.TEMP_DELETE_START, { tempPath });
+    rimraf.sync(getTempPath(basePath, options.tempFolderName));
+    bus.emitter.emit(bus.events.TEMP_DELETE_END, { tempPath });
+  }
+
+  bus.emitter.emit(bus.events.END, { entryFile, options });
+}
+
+export function emit(entryFile: string, options: Options) {
+  const tempEntryFile = toTempFilePath(entryFile, path.dirname(entryFile), options.tempFolderName);
+  bus.emitter.emit(bus.events.EMIT_START, { entryFile, tempEntryFile, options });
+
+  options.compilerOptions.outDir = path.dirname(entryFile);
+
+  const host = ts.createCompilerHost(options.compilerOptions);
+  const program = ts.createProgram([tempEntryFile], options.compilerOptions, host);
+
+  const diagnostics: ts.Diagnostic[] = [];
+
+  diagnostics.push(...program.getOptionsDiagnostics());
+  diagnostics.push(...program.getGlobalDiagnostics());
+
+  for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) {
+    diagnostics.push(...program.getSyntacticDiagnostics(sourceFile));
+    diagnostics.push(...program.getSemanticDiagnostics(sourceFile));
+  }
+
+
+  if (!check(diagnostics)) {
+    bus.emitter.emit(bus.events.DIAGNOSTICS_EMIT, { diagnostics });
+    bus.emitter.emit(bus.events.DIAGNOSTICS_EMIT_PRE, { diagnostics });
+  }
+
+  const emitResult = program.emit();
+
+  if (!check(emitResult.diagnostics)) {
+    bus.emitter.emit(bus.events.DIAGNOSTICS_EMIT, { diagnostics: emitResult.diagnostics });
+    bus.emitter.emit(bus.events.DIAGNOSTICS_EMIT_POST, { diagnostics: emitResult.diagnostics });
+  }
+
+  bus.emitter.emit(bus.events.EMIT_END, { entryFile, tempEntryFile, options });
+}
+
+function onBeforeVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node {
+  mc.setTransformationContext(tc);
+  mc.setSourceFile(node);
+  mc.setScope(node);
+
+  return node;
+}
+
+function onAfterVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node {
+  mc.addVisited(node);
+
+  return node;
+}
+
+function transformer(context: ts.TransformationContext): ts.Transformer<ts.SourceFile> {
+  const mutationContext = new MutationContext();
+
+  const visitor: ts.Visitor = (node: ts.Node): ts.Node => {
+    node = onBeforeVisit(node, mutationContext, context);
+
+    if (DEBUG && !mutationContext.wasVisited(node)) {
+      const scope = mutationContext.scope ? ts.SyntaxKind[mutationContext.scope.kind] : 'undefined';
+      console.log(`Scope: ${scope}`);
+    }
+
+    for (let mutator of mutators) {
+      node = mutator.mutateNode(node, mutationContext);
+      mutationContext.addVisited(node);
+    }
+
+    if (DEBUG && node.parent) {
+      console.log(`Kind:  ${ts.SyntaxKind[node.kind]} (${node.kind})`);
+      console.log(`File:  ${mutationContext.sourceFile.fileName}`);
+      console.log('<============================================');
+      console.log(node.getText());
+      console.log('============================================>');
+      console.log('\n\n');
+    }
+
+    node = onAfterVisit(node, mutationContext, context);
+
+    return ts.visitEachChild(node, visitor, context);
+  };
+
+  return (sf: ts.SourceFile) => ts.visitNode(sf, visitor);
+}
+
+function getOptions(options: Options = {}): Options {
+  const opts = Object.assign({}, defaultOptions, options);
+  opts.compilerOptions = Object.assign({}, defaultOptions.compilerOptions, options.compilerOptions || {});
+  return opts;
+}
+
+function getRootNames(rootNames: string | string[]): string[] {
+  if (Array.isArray(rootNames)) {
+    return rootNames;
+  }
+
+  return [rootNames];
+}
+
+function getTempPath(basePath: string, tempFolderName: string): string {
+  return path.join(basePath, tempFolderName);
+}
+
+function toTempFilePath(file: string, basePath: string, tempFolderName: string): string {
+  const pathFromBase = path.dirname(file.replace(basePath, ''));
+  const tempPath = getTempPath(basePath, tempFolderName);
+  const fileName = path.basename(file);
+
+  return path.join(tempPath, pathFromBase, fileName);
+}
+
+function check(diagnostics: ts.Diagnostic[]): boolean {
+  if (diagnostics && diagnostics.length > 0) {
+    bus.emitter.emit(bus.events.DIAGNOSTICS, { diagnostics });
+    console.error(ts.formatDiagnostics(diagnostics, {
+      getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
+      getNewLine: () => ts.sys.newLine,
+      getCanonicalFileName: (f: string) => f
+    }));
+    return false;
+  }
+
+  return true;
+}
diff --git a/tslint.json b/tslint.json
index 76f8b64..94db9d4 100644
--- a/tslint.json
+++ b/tslint.json
@@ -18,7 +18,10 @@
     "no-consecutive-blank-lines": false,
     "interface-over-type-literal": false,
     "prefer-const": false,
-    "no-var-requires": false
+    "no-var-requires": false,
+    "array-type": false,
+    "trailing-comma": false,
+    "variable-name": false
   },
   "jsRules": {
 
diff --git a/yarn.lock b/yarn.lock
index 00a3d3b..59e9730 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -36,6 +36,10 @@
   dependencies:
     "@types/node" "*"
 
+"@types/rimraf@^0.0.28":
+  version "0.0.28"
+  resolved "https://registry.yarnpkg.com/@types/rimraf/-/rimraf-0.0.28.tgz#5562519bc7963caca8abf7f128cae3b594d41d06"
+
 ansi-regex@^2.0.0:
   version "2.1.1"
   resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-2.1.1.tgz#c3b33ab5ee360d86e0e628f0468ae7ef27d654df"
@@ -44,6 +48,17 @@ ansi-styles@^2.2.1:
   version "2.2.1"
   resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-2.2.1.tgz#b432dd3358b634cf75e1e4664368240533c1ddbe"
 
+balanced-match@^0.4.1:
+  version "0.4.2"
+  resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-0.4.2.tgz#cb3f3e3c732dc0f01ee70b403f302e61d7709838"
+
+brace-expansion@^1.0.0:
+  version "1.1.6"
+  resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.6.tgz#7197d7eaa9b87e648390ea61fc66c84427420df9"
+  dependencies:
+    balanced-match "^0.4.1"
+    concat-map "0.0.1"
+
 chalk@^1.0.0, chalk@^1.1.1, chalk@^1.1.3:
   version "1.1.3"
   resolved "https://registry.yarnpkg.com/chalk/-/chalk-1.1.3.tgz#a8115c55e4a702fe4d150abd3872822a7e09fc98"
@@ -94,6 +109,10 @@ commander@^2.9.0:
   dependencies:
     graceful-readlink ">= 1.0.0"
 
+concat-map@0.0.1:
+  version "0.0.1"
+  resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
+
 escape-string-regexp@^1.0.2:
   version "1.0.5"
   resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4"
@@ -106,6 +125,21 @@ flow-runtime@^0.2.1:
   version "0.2.1"
   resolved "https://registry.yarnpkg.com/flow-runtime/-/flow-runtime-0.2.1.tgz#f9a9695b9f9c8b50a8c7f96f25af8565876bf3d7"
 
+fs.realpath@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
+
+glob@^7.0.5:
+  version "7.1.1"
+  resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.1.tgz#805211df04faaf1c63a3600306cdf5ade50b2ec8"
+  dependencies:
+    fs.realpath "^1.0.0"
+    inflight "^1.0.4"
+    inherits "2"
+    minimatch "^3.0.2"
+    once "^1.3.0"
+    path-is-absolute "^1.0.0"
+
 "graceful-readlink@>= 1.0.0":
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/graceful-readlink/-/graceful-readlink-1.0.1.tgz#4cafad76bc62f02fa039b2f94e9a3dd3a391a725"
@@ -116,7 +150,14 @@ has-ansi@^2.0.0:
   dependencies:
     ansi-regex "^2.0.0"
 
-inherits@^2.0.1:
+inflight@^1.0.4:
+  version "1.0.6"
+  resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
+  dependencies:
+    once "^1.3.0"
+    wrappy "1"
+
+inherits@2, inherits@^2.0.1:
   version "2.0.3"
   resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.3.tgz#633c2c83e3da42a502f52466022480f4208261de"
 
@@ -130,6 +171,12 @@ mimic-fn@^1.0.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-1.1.0.tgz#e667783d92e89dbd342818b5230b9d62a672ad18"
 
+minimatch@^3.0.2:
+  version "3.0.3"
+  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.3.tgz#2a4e4090b96b2db06a9d7df01055a62a77c9b774"
+  dependencies:
+    brace-expansion "^1.0.0"
+
 node-status@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/node-status/-/node-status-1.0.0.tgz#7906a7c47a6587d03496bf74ec634abaa03f8e80"
@@ -139,6 +186,12 @@ node-status@^1.0.0:
     cli-spinners "0.2.0"
     colors "1.1.2"
 
+once@^1.3.0:
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1"
+  dependencies:
+    wrappy "1"
+
 onetime@^1.0.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/onetime/-/onetime-1.1.0.tgz#a1f7838f8314c516f05ecefcbc4ccfe04b4ed789"
@@ -162,6 +215,10 @@ os-tmpdir@~1.0.1:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/os-tmpdir/-/os-tmpdir-1.0.2.tgz#bbe67406c79aa85c5cfec766fe5734555dfa1274"
 
+path-is-absolute@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
+
 restore-cursor@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-1.0.1.tgz#34661f46886327fed2991479152252df92daa541"
@@ -176,6 +233,12 @@ restore-cursor@^2.0.0:
     onetime "^2.0.0"
     signal-exit "^3.0.2"
 
+rimraf@^2.6.1:
+  version "2.6.1"
+  resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-2.6.1.tgz#c2338ec643df7a1b7fe5c54fa86f57428a55f33d"
+  dependencies:
+    glob "^7.0.5"
+
 signal-exit@^3.0.2:
   version "3.0.2"
   resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.2.tgz#b5fdc08f1287ea1178628e415e25132b73646c6d"
@@ -204,10 +267,14 @@ ts-type-info@^6.2.2:
     tmp "0.0.28"
     typescript "^2.1.4"
 
-typescript@Microsoft/TypeScript#6c122bcf16c329a21da04d7b5256f20ecc0bbd1d:
-  version "2.1.0"
-  resolved "https://codeload.github.com/Microsoft/TypeScript/tar.gz/6c122bcf16c329a21da04d7b5256f20ecc0bbd1d"
-
 typescript@^2.1.4:
   version "2.1.5"
   resolved "https://registry.yarnpkg.com/typescript/-/typescript-2.1.5.tgz#6fe9479e00e01855247cea216e7561bafcdbcd4a"
+
+typescript@next:
+  version "2.3.0-dev.20170306"
+  resolved "https://registry.yarnpkg.com/typescript/-/typescript-2.3.0-dev.20170306.tgz#1b2af5681473d13950ebc7319f120c607b6b34b4"
+
+wrappy@1:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"

From 0cb7a9b592123de19d7176370931dec724c685ab Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Wed, 15 Mar 2017 21:34:25 +0100
Subject: [PATCH 03/26] Package and linter changes.

---
 package.json | 4 ++--
 tslint.json  | 3 ++-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/package.json b/package.json
index 33a002e..7c0f1fa 100644
--- a/package.json
+++ b/package.json
@@ -13,8 +13,6 @@
     "build": "tsc --rootDir src --outDir dist --module CommonJS --target es6 --skipLibCheck"
   },
   "dependencies": {
-    "@types/chalk": "^0.4.31",
-    "@types/ora": "^0.3.31",
     "chalk": "^1.1.3",
     "commander": "^2.9.0",
     "flow-runtime": "^0.2.1",
@@ -26,10 +24,12 @@
     "typescript": "next"
   },
   "devDependencies": {
+    "@types/chalk": "^0.4.31",
     "@types/commander": "^2.3.31",
     "@types/escodegen": "^0.0.6",
     "@types/esprima": "^2.1.33",
     "@types/node": "^7.0.2",
+    "@types/ora": "^0.3.31",
     "@types/rimraf": "^0.0.28"
   }
 }
diff --git a/tslint.json b/tslint.json
index 94db9d4..4b8c6d7 100644
--- a/tslint.json
+++ b/tslint.json
@@ -21,7 +21,8 @@
     "no-var-requires": false,
     "array-type": false,
     "trailing-comma": false,
-    "variable-name": false
+    "variable-name": false,
+    "no-conditional-assignment": false
   },
   "jsRules": {
 

From e01141a0089583cd084c9dbe945b8c85ec3534ca Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Wed, 15 Mar 2017 21:34:53 +0100
Subject: [PATCH 04/26] Added util for common actions, where no context is
 needed.

---
 src/next/util.ts | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 src/next/util.ts

diff --git a/src/next/util.ts b/src/next/util.ts
new file mode 100644
index 0000000..b95f859
--- /dev/null
+++ b/src/next/util.ts
@@ -0,0 +1,37 @@
+import * as ts from 'typescript';
+
+export function setParent(node: ts.Node): void {
+  if (!node) return;
+  ts.forEachChild(node, n => {
+    n.parent = node;
+    setParent(n);
+  });
+}
+
+export function getScope(node: ts.Node): ts.Node {
+  if (node.kind === ts.SyntaxKind.SourceFile) {
+    return node;
+  }
+
+  if (this.isScope(node.kind)) {
+    return node;
+  }
+
+  return this.getScope(node.parent);
+}
+
+export function isScope(kind: ts.SyntaxKind): boolean {
+  switch (kind) {
+    case ts.SyntaxKind.SourceFile:
+    case ts.SyntaxKind.Block:
+    case ts.SyntaxKind.ModuleBlock:
+    case ts.SyntaxKind.CaseBlock:
+      return true;
+    default:
+      return false;
+  }
+}
+
+export function isKind(node: ts.Node, kind: ts.SyntaxKind): boolean {
+  return node.kind === kind;
+}

From 03f65e6aef94e63d4c73b3265a0dfc5eb13e151c Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Wed, 15 Mar 2017 21:35:31 +0100
Subject: [PATCH 05/26] Generator for recurring node structures.

---
 src/next/generator.ts | 79 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 79 insertions(+)
 create mode 100644 src/next/generator.ts

diff --git a/src/next/generator.ts b/src/next/generator.ts
new file mode 100644
index 0000000..69e4c62
--- /dev/null
+++ b/src/next/generator.ts
@@ -0,0 +1,79 @@
+import * as ts from 'typescript';
+
+export const LIB = 't';
+
+export function typeDefinition(name: string | ts.Identifier, type: string | ts.TypeNode): ts.VariableDeclaration {
+  return ts.createVariableDeclaration(name, undefined, typeAssertion(type));
+}
+
+export function typeAssertion(type: ts.TypeNode | string): ts.CallExpression {
+  if (!type) {
+    return null;
+  }
+
+  if (typeof type === 'string') {
+    return propertyAccessCall(LIB, type as string);
+  }
+
+  type = type as ts.TypeNode;
+
+  switch (type.kind) {
+    case ts.SyntaxKind.BooleanKeyword:
+    case ts.SyntaxKind.NumberKeyword:
+    case ts.SyntaxKind.StringKeyword:
+    case ts.SyntaxKind.AnyKeyword:
+      {
+        return propertyAccessCall(LIB, type.getText());
+      }
+    case ts.SyntaxKind.ArrayType:
+      {
+        const typeNode = (type as ts.ArrayTypeNode).elementType as ts.TypeNode;
+        const callExpression = propertyAccessCall(LIB, 'array', typeAssertion(typeNode));
+        return callExpression;
+      }
+    case ts.SyntaxKind.TypeReference:
+      {
+        const typeRef = type as ts.TypeReferenceNode;
+        const typeName = typeRef.typeName.getText();
+        const args: ts.CallExpression[] = [];
+        let callExpression: ts.CallExpression;
+
+        if (typeRef.typeArguments) {
+          for (const arg of typeRef.typeArguments) {
+            args.push(typeAssertion(arg));
+          }
+        }
+
+        if (typeName === 'Array' || typeName === 'array') {
+          callExpression = propertyAccessCall(LIB, 'array', args);
+        } else {
+          callExpression = propertyAccessCall(LIB, 'ref', ts.createIdentifier(typeName));
+        }
+
+        return callExpression;
+      }
+    case ts.SyntaxKind.TupleType:
+      {
+        const typeRef = type as ts.TupleTypeNode;
+        const args: ts.CallExpression[] = [];
+
+        for (const arg of typeRef.elementTypes) {
+          args.push(typeAssertion(arg));
+        }
+
+        return propertyAccessCall(LIB, 'tuple', args);
+      }
+    default:
+      {
+        return propertyAccessCall(LIB, 'any');
+      }
+  }
+}
+
+export function propertyAccessCall(id: string | ts.Expression, prop: string | ts.Identifier, args: ts.Expression | ts.Expression[] = [], types: ts.TypeNode | ts.TypeNode[] = []): ts.CallExpression {
+  id = typeof id === 'string' ? ts.createIdentifier(id) : id;
+  args = Array.isArray(args) ? args : [args];
+  types = Array.isArray(types) ? types : [types];
+
+  return ts.createCall(ts.createPropertyAccess(id, prop), types, args);
+}

From 37d7b68b8c32ed9119cbe05723a2f4b438457095 Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Wed, 15 Mar 2017 21:36:12 +0100
Subject: [PATCH 06/26] Added and removed mutators. Changes to base class.

---
 src/next/mutators/IdentifierMutator.ts        | 21 -----
 src/next/mutators/ImportSpecifierMutator.ts   | 15 ----
 .../mutators/InterfaceDeclararionMutator.ts   |  2 +-
 src/next/mutators/Mutator.ts                  | 19 ++---
 .../VariableDeclarationListMutator.ts         | 83 +++++++++++++++++++
 5 files changed, 93 insertions(+), 47 deletions(-)
 delete mode 100644 src/next/mutators/IdentifierMutator.ts
 delete mode 100644 src/next/mutators/ImportSpecifierMutator.ts
 create mode 100644 src/next/mutators/VariableDeclarationListMutator.ts

diff --git a/src/next/mutators/IdentifierMutator.ts b/src/next/mutators/IdentifierMutator.ts
deleted file mode 100644
index 93f2be1..0000000
--- a/src/next/mutators/IdentifierMutator.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import * as ts from 'typescript';
-import { Mutator } from './Mutator';
-import { MutationContext } from '../context'
-
-export class IdentifierMutator extends Mutator {
-
-  protected kind = ts.SyntaxKind.Identifier;
-
-  public mutate(node: ts.Identifier, context: MutationContext): ts.Node {
-    // console.log(node.getText());
-    // console.log(node.modifiers);
-    // console.log(node.originalKeywordKind);
-    // console.log(ts.NodeFlags[node.flags]);
-
-    // const flags = ts.getCombinedModifierFlags(node);
-    // console.log(flags);
-
-    return node;
-  }
-
-}
diff --git a/src/next/mutators/ImportSpecifierMutator.ts b/src/next/mutators/ImportSpecifierMutator.ts
deleted file mode 100644
index 4a6d0e2..0000000
--- a/src/next/mutators/ImportSpecifierMutator.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import * as ts from 'typescript';
-import { Mutator } from './Mutator';
-import { MutationContext } from '../context'
-
-export class ImportSpecifierMutator extends Mutator {
-
-  protected kind = ts.SyntaxKind.ImportSpecifier;
-
-  public mutate(node: ts.ImportSpecifier, context: MutationContext): ts.Node {
-    // const flags = ts.getCombinedModifierFlags(node);
-    // console.log(flags);
-    return node;
-  }
-
-}
diff --git a/src/next/mutators/InterfaceDeclararionMutator.ts b/src/next/mutators/InterfaceDeclararionMutator.ts
index 7256a13..0d73e73 100644
--- a/src/next/mutators/InterfaceDeclararionMutator.ts
+++ b/src/next/mutators/InterfaceDeclararionMutator.ts
@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
 import { Mutator } from './Mutator';
-import { MutationContext } from '../context'
+import { MutationContext } from '../context';
 
 export class InterfaceDeclarationMutator extends Mutator {
 
diff --git a/src/next/mutators/Mutator.ts b/src/next/mutators/Mutator.ts
index 263d779..a5454a4 100644
--- a/src/next/mutators/Mutator.ts
+++ b/src/next/mutators/Mutator.ts
@@ -9,11 +9,18 @@ export abstract class Mutator {
   protected abstract mutate(node: ts.Node, context?: MutationContext): ts.Node;
 
   public mutateNode(node: ts.Node, context: MutationContext): ts.Node {
-    if (!this.shouldMutate(node.kind)) {
+    if (this.getKind().indexOf(node.kind) === -1) {
       return node;
     }
 
-    return this.mutate(node, context);
+    if (context.wasVisited(node)) {
+      return node;
+    }
+
+    const substitution = this.mutate(node, context);
+    context.addVisited(substitution);
+
+    return substitution;
   }
 
   public getKind(): ts.SyntaxKind[] {
@@ -24,12 +31,4 @@ export abstract class Mutator {
     return [this.kind];
   }
 
-  public shouldMutate(kind: ts.SyntaxKind): boolean {
-    if (this.getKind().indexOf(kind) !== -1) {
-      return true;
-    }
-
-    return false;
-  }
-
 }
diff --git a/src/next/mutators/VariableDeclarationListMutator.ts b/src/next/mutators/VariableDeclarationListMutator.ts
new file mode 100644
index 0000000..32ba992
--- /dev/null
+++ b/src/next/mutators/VariableDeclarationListMutator.ts
@@ -0,0 +1,83 @@
+import * as ts from 'typescript';
+import * as generator from '../generator';
+import { Mutator } from './Mutator';
+import { MutationContext } from '../context';
+
+export class VariableDeclarationListMutator extends Mutator {
+
+  protected kind = ts.SyntaxKind.VariableDeclarationList;
+
+  public mutate(node: ts.VariableDeclarationList, context: MutationContext): ts.Node {
+    if (!node.declarations) {
+      return node;
+    }
+
+    const declarations: ts.VariableDeclaration[] = [];
+
+    for (const declaration of node.declarations) {
+      const transformed = this.transformDeclaration(declaration, context);
+      transformed.forEach(n => context.addVisited(n, true));
+      declarations.push(...transformed);
+    }
+
+    return ts.updateVariableDeclarationList(node, declarations);
+  }
+
+  private transformDeclaration(node: ts.VariableDeclaration, context: MutationContext): ts.VariableDeclaration[] {
+    if (context.wasVisited(node)) {
+      return [node];
+    }
+
+    const isConst = node.parent && node.parent.flags === ts.NodeFlags.Const;
+
+    if (!node.type) {
+      if (isConst) {
+        return this.transformUntypedConstDeclaration(node);
+      }
+
+      return this.transformUntypedLetDeclaration(node);
+    }
+
+    if (isConst) {
+      return this.transformConstDeclaration(node);
+    }
+
+    return this.transformLetDeclaration(node);
+  }
+
+  private transformLetDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] {
+    const nodeName = node.name.getText();
+    const typeDefinition = generator.typeDefinition(`_${nodeName}Type`, node.type);
+
+    if (!node.initializer) {
+      return [typeDefinition, node];
+    }
+
+    const initializer = generator.propertyAccessCall(`_${nodeName}Type`, 'assert', node.initializer);
+    const assignment = ts.updateVariableDeclaration(node, node.name, node.type, initializer);
+
+    return [typeDefinition, assignment];
+  }
+
+  private transformConstDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] {
+    const nodeName = node.name.getText();
+    const typeCalls = generator.typeAssertion(node.type);
+
+    const initializer = ts.createCall(
+      ts.createPropertyAccess(typeCalls, 'assert'), [], [node.initializer],
+    );
+
+    const assignment = ts.updateVariableDeclaration(node, node.name, node.type, initializer);
+
+    return [assignment];
+  }
+
+  private transformUntypedLetDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] {
+    return [node];
+  }
+
+  private transformUntypedConstDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] {
+    return [node];
+  }
+
+}

From 6fa626c498c91e298cb3e482cb7acd8cd5669f4f Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Wed, 15 Mar 2017 21:36:32 +0100
Subject: [PATCH 07/26] Moved common actions to util. Fixes.

---
 src/next/context.ts | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/next/context.ts b/src/next/context.ts
index f9cbf6f..a0ce6d1 100644
--- a/src/next/context.ts
+++ b/src/next/context.ts
@@ -1,4 +1,5 @@
 import * as ts from 'typescript';
+import * as util from './util';
 
 export type Scope = ts.SourceFile | ts.Block | ts.ModuleBlock | ts.CaseBlock;
 
@@ -83,7 +84,7 @@ export class MutationContext {
         this._scope = node as Scope;
         break;
       default:
-      // throw new Error(`Scope must be SourceFile, Block, ModuleBlock or CaseBlock, got ${ts.SyntaxKind[node.kind]}.`);
+      throw new Error(`Scope must be SourceFile, Block, ModuleBlock or CaseBlock, got ${ts.SyntaxKind[node.kind]}.`);
     }
   }
 
@@ -92,9 +93,11 @@ export class MutationContext {
   }
 
   set sourceFile(sourceFile: ts.SourceFile) {
-    if (sourceFile.kind === ts.SyntaxKind.SourceFile) {
-      this._sourceFile = sourceFile;
+    if (!util.isKind(sourceFile, ts.SyntaxKind.SourceFile)) {
+      throw new Error(`Attemt to set invalid node as SourceFile, got ${ts.SyntaxKind[sourceFile.kind]}.`);
     }
+
+    this._sourceFile = sourceFile;
   }
 
 }

From d6f692535c4f28de5ed5aeab58481d9f808e4148 Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Wed, 15 Mar 2017 21:37:05 +0100
Subject: [PATCH 08/26] Change to latest mutator instances.

---
 src/next/mutators.ts | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/next/mutators.ts b/src/next/mutators.ts
index 975aa67..8b0c215 100644
--- a/src/next/mutators.ts
+++ b/src/next/mutators.ts
@@ -1,11 +1,9 @@
 import { Mutator } from './mutators/Mutator';
 
-import { IdentifierMutator } from './mutators/IdentifierMutator';
-import { ImportSpecifierMutator } from './mutators/ImportSpecifierMutator';
 import { InterfaceDeclarationMutator } from './mutators/InterfaceDeclararionMutator';
+import { VariableDeclarationListMutator } from './mutators/VariableDeclarationListMutator';
 
 export const mutators: Mutator[] = [
-  new IdentifierMutator(),
-  new ImportSpecifierMutator(),
-  new InterfaceDeclarationMutator()
+  new InterfaceDeclarationMutator(),
+  new VariableDeclarationListMutator(),
 ];

From 4c646aa49f9d2503bb735745fdcb633ce3d5956a Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Wed, 15 Mar 2017 21:38:02 +0100
Subject: [PATCH 09/26] Restore parent nodes. Determine correct scope. Other
 improvements and fixes.

---
 src/next/transform.ts | 84 +++++++++++++++++++++++++++----------------
 1 file changed, 54 insertions(+), 30 deletions(-)

diff --git a/src/next/transform.ts b/src/next/transform.ts
index 0f035bb..a174c25 100644
--- a/src/next/transform.ts
+++ b/src/next/transform.ts
@@ -1,6 +1,7 @@
 import * as path from 'path';
 import * as rimraf from 'rimraf';
 import * as ts from 'typescript';
+import * as util from './util';
 import * as bus from './bus';
 import { MutationContext } from './context';
 import { mutators } from './mutators';
@@ -10,7 +11,7 @@ const DEBUG = true;
 
 export function transform(entryFile: string, options?: Options): void {
   options = getOptions(options);
-  bus.emitter.emit(bus.events.START, { entryFile, options });
+  notify(bus.events.START, { entryFile, options });
 
   const basePath = path.dirname(entryFile);
   const host = ts.createCompilerHost(options.compilerOptions);
@@ -27,19 +28,19 @@ export function transform(entryFile: string, options?: Options): void {
   }
 
   if (!check(diagnostics)) {
-    bus.emitter.emit(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics });
-    bus.emitter.emit(bus.events.DIAGNOSTICS_TRANSFORM_PRE, { diagnostics });
+    notify(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics });
+    notify(bus.events.DIAGNOSTICS_TRANSFORM_PRE, { diagnostics });
   }
 
   const sourceFiles = program.getSourceFiles().filter(sf => !sf.isDeclarationFile);
 
-  bus.emitter.emit(bus.events.TRANSFORM_START, { sourceFiles });
+  notify(bus.events.TRANSFORM_START, { sourceFiles });
   const result = ts.transform(sourceFiles, [transformer], options.compilerOptions);
-  bus.emitter.emit(bus.events.TRANSFORM_END, { sourceFiles: result.transformed });
+  notify(bus.events.TRANSFORM_END, { sourceFiles: result.transformed });
 
   if (!check(result.diagnostics)) {
-    bus.emitter.emit(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics });
-    bus.emitter.emit(bus.events.DIAGNOSTICS_TRANSFORM_POST, { diagnostics: result.diagnostics });
+    notify(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics });
+    notify(bus.events.DIAGNOSTICS_TRANSFORM_POST, { diagnostics: result.diagnostics });
   }
 
   const printerOptions: ts.PrinterOptions = {
@@ -53,7 +54,7 @@ export function transform(entryFile: string, options?: Options): void {
     }
   };
 
-  bus.emitter.emit(bus.events.WRITE_START, { count: result.transformed.length });
+  notify(bus.events.WRITE_START, { count: result.transformed.length });
   const printer = ts.createPrinter(printerOptions, printHandlers);
 
   let count = 0;
@@ -61,29 +62,30 @@ export function transform(entryFile: string, options?: Options): void {
     count++;
     const location = toTempFilePath(transformed.fileName, basePath, options.tempFolderName);
     const source = printer.printFile(transformed);
-    bus.emitter.emit(bus.events.WRITE_FILE_START, { location, transformed, source });
+    notify(bus.events.WRITE_FILE_START, { location, transformed, source });
     ts.sys.writeFile(location, source);
-    bus.emitter.emit(bus.events.WRITE_FILE_END, { location, transformed, source });
+    notify(bus.events.WRITE_FILE_END, { location, transformed, source });
   }
 
-  bus.emitter.emit(bus.events.WRITE_END, { count });
+  notify(bus.events.WRITE_END, { count });
+
   result.dispose();
 
   emit(entryFile, options);
 
   if (!options.keepTempFiles) {
     const tempPath = getTempPath(basePath, options.tempFolderName);
-    bus.emitter.emit(bus.events.TEMP_DELETE_START, { tempPath });
+    notify(bus.events.TEMP_DELETE_START, { tempPath });
     rimraf.sync(getTempPath(basePath, options.tempFolderName));
-    bus.emitter.emit(bus.events.TEMP_DELETE_END, { tempPath });
+    notify(bus.events.TEMP_DELETE_END, { tempPath });
   }
 
-  bus.emitter.emit(bus.events.END, { entryFile, options });
+  notify(bus.events.END, { entryFile, options });
 }
 
 export function emit(entryFile: string, options: Options) {
   const tempEntryFile = toTempFilePath(entryFile, path.dirname(entryFile), options.tempFolderName);
-  bus.emitter.emit(bus.events.EMIT_START, { entryFile, tempEntryFile, options });
+  notify(bus.events.EMIT_START, { entryFile, tempEntryFile, options });
 
   options.compilerOptions.outDir = path.dirname(entryFile);
 
@@ -102,31 +104,33 @@ export function emit(entryFile: string, options: Options) {
 
 
   if (!check(diagnostics)) {
-    bus.emitter.emit(bus.events.DIAGNOSTICS_EMIT, { diagnostics });
-    bus.emitter.emit(bus.events.DIAGNOSTICS_EMIT_PRE, { diagnostics });
+    notify(bus.events.DIAGNOSTICS_EMIT, { diagnostics });
+    notify(bus.events.DIAGNOSTICS_EMIT_PRE, { diagnostics });
   }
 
   const emitResult = program.emit();
 
   if (!check(emitResult.diagnostics)) {
-    bus.emitter.emit(bus.events.DIAGNOSTICS_EMIT, { diagnostics: emitResult.diagnostics });
-    bus.emitter.emit(bus.events.DIAGNOSTICS_EMIT_POST, { diagnostics: emitResult.diagnostics });
+    notify(bus.events.DIAGNOSTICS_EMIT, { diagnostics: emitResult.diagnostics });
+    notify(bus.events.DIAGNOSTICS_EMIT_POST, { diagnostics: emitResult.diagnostics });
   }
 
-  bus.emitter.emit(bus.events.EMIT_END, { entryFile, tempEntryFile, options });
+  notify(bus.events.EMIT_END, { entryFile, tempEntryFile, options });
 }
 
 function onBeforeVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node {
+  if (util.isKind(node, ts.SyntaxKind.SourceFile)) {
+    mc.setSourceFile(node);
+  }
+
   mc.setTransformationContext(tc);
-  mc.setSourceFile(node);
-  mc.setScope(node);
+  mc.setScope(util.getScope(node));
 
   return node;
 }
 
 function onAfterVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node {
   mc.addVisited(node);
-
   return node;
 }
 
@@ -134,24 +138,40 @@ function transformer(context: ts.TransformationContext): ts.Transformer<ts.Sourc
   const mutationContext = new MutationContext();
 
   const visitor: ts.Visitor = (node: ts.Node): ts.Node => {
+    const parent = node.parent;
     node = onBeforeVisit(node, mutationContext, context);
 
-    if (DEBUG && !mutationContext.wasVisited(node)) {
+    if (DEBUG) {
       const scope = mutationContext.scope ? ts.SyntaxKind[mutationContext.scope.kind] : 'undefined';
+      console.log(`Visited: ${mutationContext.wasVisited(node) ? 'Yes' : 'No'}`)
       console.log(`Scope: ${scope}`);
+      console.log(`Kind:  ${ts.SyntaxKind[node.kind]} (${node.kind})`);
+      console.log(`File:  ${mutationContext.sourceFile.fileName}`);
     }
 
     for (let mutator of mutators) {
       node = mutator.mutateNode(node, mutationContext);
-      mutationContext.addVisited(node);
     }
 
-    if (DEBUG && node.parent) {
-      console.log(`Kind:  ${ts.SyntaxKind[node.kind]} (${node.kind})`);
-      console.log(`File:  ${mutationContext.sourceFile.fileName}`);
+    node.parent = parent;
+    util.setParent(node);
+
+    if (DEBUG) {
       console.log('<============================================');
-      console.log(node.getText());
+      if (node.parent) {
+        if (node.flags === ts.NodeFlags.Synthesized) {
+          console.log('Cannot get text of synthesized node.');
+        } else {
+          console.log(node.getText());
+        }
+      } else {
+        console.log('Parent not set, cannot get text.');
+      }
       console.log('============================================>');
+    }
+
+
+    if (DEBUG) {
       console.log('\n\n');
     }
 
@@ -191,7 +211,7 @@ function toTempFilePath(file: string, basePath: string, tempFolderName: string):
 
 function check(diagnostics: ts.Diagnostic[]): boolean {
   if (diagnostics && diagnostics.length > 0) {
-    bus.emitter.emit(bus.events.DIAGNOSTICS, { diagnostics });
+    notify(bus.events.DIAGNOSTICS, { diagnostics });
     console.error(ts.formatDiagnostics(diagnostics, {
       getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
       getNewLine: () => ts.sys.newLine,
@@ -202,3 +222,7 @@ function check(diagnostics: ts.Diagnostic[]): boolean {
 
   return true;
 }
+
+function notify(event: string | symbol, ...args: any[]): boolean {
+  return bus.emitter.emit(event, args);
+}

From 4c39f47a4135eee16dd803f7d0e522368070d928 Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Wed, 15 Mar 2017 21:38:44 +0100
Subject: [PATCH 10/26] Package exports.

---
 src/next/index.ts | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/next/index.ts b/src/next/index.ts
index 4e90cce..85a7872 100644
--- a/src/next/index.ts
+++ b/src/next/index.ts
@@ -1,4 +1,9 @@
-export * from './bus';
+import * as b from './bus';
+export const bus = b;
+
+import * as u from './util';
+export const util = u;
+
 export * from './context';
 export * from './mutators';
 export * from './options';

From 7fb159e8f53e8d226aab4191472972bf2b208975 Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Wed, 15 Mar 2017 21:39:29 +0100
Subject: [PATCH 11/26] Temporary test files.

---
 src/test/config-2017-03-10_17-40-38-656.ts |   3 +
 src/test/factory.ts                        |  87 ++++++++++++++++
 src/test/source.js                         |   2 +
 src/test/source.ts                         |   5 +
 src/test/test.ts                           |  17 ++++
 src/test/transformer.ts                    |  19 ++++
 src/test/v1.ts                             |  38 +++++++
 src/test/v2/.tsr/source.ts                 |  11 +++
 src/test/v2/.tsr/source2.ts                |   2 +
 src/test/v2/.tsr/source3.ts                |   1 +
 src/test/v2/.tsr/source4.ts                |  10 ++
 src/test/v2/source.js                      |  11 +++
 src/test/v2/source.ts                      |  15 +++
 src/test/v2/source2.js                     |   2 +
 src/test/v2/source2.ts                     |   5 +
 src/test/v2/source3.js                     |   1 +
 src/test/v2/source3.ts                     |   1 +
 src/test/v2/source4.js                     |   7 ++
 src/test/v2/source4.ts                     |  13 +++
 src/test/v2/test.ts                        |   6 ++
 src/test/v2/test2.ts                       |   4 +
 src/test/v2/transform.old.ts               | 110 +++++++++++++++++++++
 22 files changed, 370 insertions(+)
 create mode 100644 src/test/config-2017-03-10_17-40-38-656.ts
 create mode 100644 src/test/factory.ts
 create mode 100644 src/test/source.js
 create mode 100644 src/test/source.ts
 create mode 100644 src/test/test.ts
 create mode 100644 src/test/transformer.ts
 create mode 100644 src/test/v1.ts
 create mode 100644 src/test/v2/.tsr/source.ts
 create mode 100644 src/test/v2/.tsr/source2.ts
 create mode 100644 src/test/v2/.tsr/source3.ts
 create mode 100644 src/test/v2/.tsr/source4.ts
 create mode 100644 src/test/v2/source.js
 create mode 100644 src/test/v2/source.ts
 create mode 100644 src/test/v2/source2.js
 create mode 100644 src/test/v2/source2.ts
 create mode 100644 src/test/v2/source3.js
 create mode 100644 src/test/v2/source3.ts
 create mode 100644 src/test/v2/source4.js
 create mode 100644 src/test/v2/source4.ts
 create mode 100644 src/test/v2/test.ts
 create mode 100644 src/test/v2/test2.ts
 create mode 100644 src/test/v2/transform.old.ts

diff --git a/src/test/config-2017-03-10_17-40-38-656.ts b/src/test/config-2017-03-10_17-40-38-656.ts
new file mode 100644
index 0000000..c5dbbef
--- /dev/null
+++ b/src/test/config-2017-03-10_17-40-38-656.ts
@@ -0,0 +1,3 @@
+export interface TsRuntimeConfig {
+
+}
diff --git a/src/test/factory.ts b/src/test/factory.ts
new file mode 100644
index 0000000..7d36e74
--- /dev/null
+++ b/src/test/factory.ts
@@ -0,0 +1,87 @@
+import * as path from 'path';
+import * as ts from 'typescript';
+
+function transformer(context: ts.TransformationContext): ts.Transformer<ts.SourceFile> {
+  const visitor: ts.Visitor = (node: ts.Node): ts.Node => {
+    return visitEachChildFirst(node, visitor, context);
+  };
+
+  const transformer: ts.Transformer<ts.SourceFile> = (sf: ts.SourceFile) => ts.visitNode(sf, visitor);
+
+  return transformer;
+}
+
+function transform(node: ts.Node, context: ts.TransformationContext): ts.Node {
+  console.log('<--------------------');
+  console.log(node.getText());
+  console.log('-------------------->');
+  console.log('');
+
+  if (node === null) return null;
+
+  if (node.kind === ts.SyntaxKind.FunctionDeclaration) {
+    return null;
+  }
+
+  return node;
+}
+
+function visitEachChild(node: ts.Node, visitor: ts.Visitor, context: ts.TransformationContext): ts.Node {
+  node = transform(node, context);
+  if (node === null) return null;
+  return ts.visitEachChild(node, visitor, context);
+}
+
+function visitEachChildFirst(node: ts.Node, visitor: ts.Visitor, context: ts.TransformationContext): ts.Node {
+  node = ts.visitEachChild(node, visitor, context);
+  return transform(node, context);
+}
+
+function check(diagnostics: ts.Diagnostic[]): boolean {
+  if (diagnostics && diagnostics.length > 0) {
+    console.error(ts.formatDiagnostics(diagnostics, {
+      getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
+      getNewLine: () => ts.sys.newLine,
+      getCanonicalFileName: (f: string) => f
+    }));
+    return false;
+  }
+
+  return true;
+}
+
+function main() {
+  const options: ts.CompilerOptions = {
+    skipLibCheck: true,
+    experimentalDecorators: true,
+    noEmitOnError: false,
+  };
+
+  const beforeTransforms = [transformer];
+  const afterTransforms: ts.TransformerFactory<ts.SourceFile>[] = [];
+
+  const compilerHost = ts.createCompilerHost(options);
+  const program = ts.createProgram([path.join(__dirname, './source.ts')], options, compilerHost);
+
+  const diags: ts.Diagnostic[] = [];
+
+  diags.push(...program.getOptionsDiagnostics());
+  diags.push(...program.getGlobalDiagnostics());
+
+  for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) {
+    diags.push(...program.getSyntacticDiagnostics(sourceFile));
+    diags.push(...program.getSemanticDiagnostics(sourceFile));
+  }
+
+  console.log('check before emit');
+  check(diags);
+
+  const { diagnostics } = program.emit(
+    undefined, undefined, undefined, undefined, { before: beforeTransforms, after: afterTransforms }
+  );
+
+  console.log('check after emit');
+  check(diagnostics);
+}
+
+main();
diff --git a/src/test/source.js b/src/test/source.js
new file mode 100644
index 0000000..f0a037a
--- /dev/null
+++ b/src/test/source.js
@@ -0,0 +1,2 @@
+var test = 10;
+var test = 11;
diff --git a/src/test/source.ts b/src/test/source.ts
new file mode 100644
index 0000000..d76d110
--- /dev/null
+++ b/src/test/source.ts
@@ -0,0 +1,5 @@
+let test: number = 10;
+let test: boolean = 11;
+function hello(x: number): boolean {
+  return true;
+}
diff --git a/src/test/test.ts b/src/test/test.ts
new file mode 100644
index 0000000..2d3c7e6
--- /dev/null
+++ b/src/test/test.ts
@@ -0,0 +1,17 @@
+import * as ts from "typescript";
+
+export function runNameofOnFiles(filePaths: string[]) {
+  const results: { fileName: string; text: string; }[] = [];
+  const compilerOptions: ts.CompilerOptions = {
+    strictNullChecks: true,
+    target: ts.ScriptTarget.ES2017
+  };
+  const transformers: ts.CustomTransformers = {
+    before: [nameofTransformFactory],
+    after: []
+  };
+  const program = ts.createProgram(filePaths, compilerOptions);
+  program.emit(undefined, (fileName, text) => results.push({ fileName, text }), undefined, false, transformers);
+
+  return results;
+}
diff --git a/src/test/transformer.ts b/src/test/transformer.ts
new file mode 100644
index 0000000..c77db30
--- /dev/null
+++ b/src/test/transformer.ts
@@ -0,0 +1,19 @@
+import * as ts from 'typescript';
+
+export function transformer(context: ts.TransformationContext):
+  ts.Transformer<ts.SourceFile> {
+  const visitor: ts.Visitor = (node: ts.Node): ts.Node => {
+    switch (node.kind) {
+      case ts.SyntaxKind.Decorator:
+        // drop on the floor;
+        return null as any;
+      default:
+        return ts.visitEachChild(node, visitor, context);
+    }
+  };
+
+  const transformer: ts.Transformer<ts.SourceFile> = (sf: ts.SourceFile) =>
+    ts.visitNode(sf, visitor);
+
+  return transformer;
+}
diff --git a/src/test/v1.ts b/src/test/v1.ts
new file mode 100644
index 0000000..84263c3
--- /dev/null
+++ b/src/test/v1.ts
@@ -0,0 +1,38 @@
+import * as ts from 'typescript';
+
+function transform(options: ts.CompilerOptions, fileNames: string[], allDiagnostics: ts.Diagnostic[]): any {
+  const files = new Map<string, string>();
+  const program = ts.createProgram(fileNames, options);
+
+  {
+    const diagnostics = ts.getPreEmitDiagnostics(program);
+    if (diagnostics.length > 0) {
+      allDiagnostics.push(...diagnostics);
+      logDiagnostics(allDiagnostics);
+      return null;
+    }
+  }
+
+  const emitResult = program.emit(undefined);
+
+  if (emitResult.diagnostics.length > 0) {
+    allDiagnostics.push(...emitResult.diagnostics);
+    logDiagnostics(allDiagnostics);
+    return null;
+  }
+
+  const exitCode = emitResult.emitSkipped ? 1 : 0;
+  console.log(`Process exiting with code '${exitCode}'.`);
+
+  return emitResult;
+}
+
+function logDiagnostics(allDiagnostics: ts.Diagnostic[]) {
+  allDiagnostics.forEach(diagnostic => {
+    let { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+    let message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+    console.log(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
+  });
+}
+
+const emitResult = transform({}, ['test1.ts'], []);
diff --git a/src/test/v2/.tsr/source.ts b/src/test/v2/.tsr/source.ts
new file mode 100644
index 0000000..a435ad7
--- /dev/null
+++ b/src/test/v2/.tsr/source.ts
@@ -0,0 +1,11 @@
+import { a, TestInterface } from './source2';
+import { bla } from './source3';
+console.log(a);
+console.log(bla);
+console.log(TestInterface);
+class Test implements TestInterface {
+    public test(): string {
+        let a = 'hi';
+        return a;
+    }
+}
diff --git a/src/test/v2/.tsr/source2.ts b/src/test/v2/.tsr/source2.ts
new file mode 100644
index 0000000..57e4e57
--- /dev/null
+++ b/src/test/v2/.tsr/source2.ts
@@ -0,0 +1,2 @@
+export const TestInterface = Symbol("TestInterface");
+export const a = 'hi';
diff --git a/src/test/v2/.tsr/source3.ts b/src/test/v2/.tsr/source3.ts
new file mode 100644
index 0000000..c019563
--- /dev/null
+++ b/src/test/v2/.tsr/source3.ts
@@ -0,0 +1 @@
+export const bla = 'bla';
diff --git a/src/test/v2/.tsr/source4.ts b/src/test/v2/.tsr/source4.ts
new file mode 100644
index 0000000..027a7c7
--- /dev/null
+++ b/src/test/v2/.tsr/source4.ts
@@ -0,0 +1,10 @@
+type TestType = {
+    name: string;
+};
+const a: string = t.string().assert(10);
+let _bType = t.array(t.number()), b: number[];
+b = [a];
+function testFunction(t: TestType): string {
+    return 'Hello ' + t.name;
+}
+console.log(testFunction({ name: 'Alice' }));
diff --git a/src/test/v2/source.js b/src/test/v2/source.js
new file mode 100644
index 0000000..f482f67
--- /dev/null
+++ b/src/test/v2/source.js
@@ -0,0 +1,11 @@
+import { a, TestInterface } from './source2';
+import { bla } from './source3';
+console.log(a);
+console.log(bla);
+console.log(TestInterface);
+class Test {
+    test() {
+        let a = 'hi';
+        return a;
+    }
+}
diff --git a/src/test/v2/source.ts b/src/test/v2/source.ts
new file mode 100644
index 0000000..4a84eb7
--- /dev/null
+++ b/src/test/v2/source.ts
@@ -0,0 +1,15 @@
+import { a, TestInterface } from './source2';
+import { bla } from './source3';
+
+console.log(a);
+console.log(bla);
+console.log(TestInterface);
+
+class Test implements TestInterface {
+
+  public test(): string {
+    let a = 'hi';
+    return a;
+  }
+
+}
diff --git a/src/test/v2/source2.js b/src/test/v2/source2.js
new file mode 100644
index 0000000..57e4e57
--- /dev/null
+++ b/src/test/v2/source2.js
@@ -0,0 +1,2 @@
+export const TestInterface = Symbol("TestInterface");
+export const a = 'hi';
diff --git a/src/test/v2/source2.ts b/src/test/v2/source2.ts
new file mode 100644
index 0000000..888f0ea
--- /dev/null
+++ b/src/test/v2/source2.ts
@@ -0,0 +1,5 @@
+export interface TestInterface {
+
+}
+
+export const a = 'hi';
diff --git a/src/test/v2/source3.js b/src/test/v2/source3.js
new file mode 100644
index 0000000..c019563
--- /dev/null
+++ b/src/test/v2/source3.js
@@ -0,0 +1 @@
+export const bla = 'bla';
diff --git a/src/test/v2/source3.ts b/src/test/v2/source3.ts
new file mode 100644
index 0000000..c019563
--- /dev/null
+++ b/src/test/v2/source3.ts
@@ -0,0 +1 @@
+export const bla = 'bla';
diff --git a/src/test/v2/source4.js b/src/test/v2/source4.js
new file mode 100644
index 0000000..4017790
--- /dev/null
+++ b/src/test/v2/source4.js
@@ -0,0 +1,7 @@
+const a = t.string().assert(10);
+let _bType = t.array(t.number()), b;
+b = [a];
+function testFunction(t) {
+    return 'Hello ' + t.name;
+}
+console.log(testFunction({ name: 'Alice' }));
diff --git a/src/test/v2/source4.ts b/src/test/v2/source4.ts
new file mode 100644
index 0000000..4d5ad9f
--- /dev/null
+++ b/src/test/v2/source4.ts
@@ -0,0 +1,13 @@
+type TestType = {
+  name: string;
+}
+
+const a: string = 10;
+let b: number[];
+b = [a];
+
+function testFunction (t: TestType): string {
+  return 'Hello ' + t.name;
+}
+
+console.log(testFunction({name: 'Alice'}));
diff --git a/src/test/v2/test.ts b/src/test/v2/test.ts
new file mode 100644
index 0000000..1ce7016
--- /dev/null
+++ b/src/test/v2/test.ts
@@ -0,0 +1,6 @@
+import * as path from 'path';
+import * as tsr from '../../next/';
+
+tsr.transform(path.join(__dirname, './source4.ts'), {
+  compilerOptions: {}
+});
diff --git a/src/test/v2/test2.ts b/src/test/v2/test2.ts
new file mode 100644
index 0000000..7c04d03
--- /dev/null
+++ b/src/test/v2/test2.ts
@@ -0,0 +1,4 @@
+import * as path from 'path';
+import { transform } from './transform2';
+
+transform(path.join(__dirname, '../test/v2/source.ts'));
diff --git a/src/test/v2/transform.old.ts b/src/test/v2/transform.old.ts
new file mode 100644
index 0000000..3e38796
--- /dev/null
+++ b/src/test/v2/transform.old.ts
@@ -0,0 +1,110 @@
+import * as ts from 'typescript';
+import { bus, messages } from './bus';
+import { Options, defaultOptions } from './options';
+import { Mutator } from './mutators/Mutator';
+import { MutationContext } from './context';
+import { mutators } from './mutators';
+
+const DEBUG = true;
+
+export function transform(files: string | string[], options?: Options): ts.EmitResult {
+  const compilerOptions = Object.assign({}, defaultOptions.compilerOptions, options.compilerOptions);
+  const opts = Object.assign({}, defaultOptions, options);
+  opts.compilerOptions = compilerOptions;
+
+  const rootNames = Array.isArray(files) ? files : [files];
+
+  const compilerHost = ts.createCompilerHost(compilerOptions);
+  const program = ts.createProgram(rootNames, compilerOptions, compilerHost);
+
+  const diags: ts.Diagnostic[] = [];
+
+  diags.push(...program.getOptionsDiagnostics());
+  diags.push(...program.getGlobalDiagnostics());
+
+  for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) {
+    diags.push(...program.getSyntacticDiagnostics(sourceFile));
+    diags.push(...program.getSemanticDiagnostics(sourceFile));
+  }
+
+  check(diags);
+
+  const beforeTransforms: ts.TransformerFactory<ts.SourceFile>[] = [beforeTransformer];
+  const afterTransforms: ts.TransformerFactory<ts.SourceFile>[] = [afterTransformer];
+
+  const emitResult = program.emit(
+    undefined, undefined, undefined, undefined,
+    { before: beforeTransforms, after: afterTransforms }
+  );
+
+  check(emitResult.diagnostics);
+
+  return emitResult;
+}
+
+function onBeforeVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node {
+  mc.setTransformationContext(tc);
+  mc.setScope(node);
+
+  return node;
+}
+
+function onAfterVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node {
+  mc.addVisited(node);
+
+  return node;
+}
+
+function beforeTransformer(context: ts.TransformationContext): ts.Transformer<ts.SourceFile> {
+  const mutationContext = new MutationContext();
+
+  const visitor: ts.Visitor = (node: ts.Node): ts.Node => {
+    node = onBeforeVisit(node, mutationContext, context);
+
+    if (DEBUG && !mutationContext.wasVisited(node)) {
+      const scope = mutationContext.scope ? ts.SyntaxKind[mutationContext.scope.kind] : 'undefined';
+      console.log(`Scope: ${scope}`);
+    }
+
+    for (let mutator of mutators) {
+      node = mutator.mutateNode(node, mutationContext);
+      mutationContext.addVisited(node);
+    }
+
+    if (DEBUG && node.parent) {
+      console.log(`Kind:  ${ts.SyntaxKind[node.kind]}`);
+      console.log('<===================');
+      console.log(node.getText());
+      console.log('==================>');
+      console.log('\n\n');
+    }
+
+    node = onAfterVisit(node, mutationContext, context);
+
+    return ts.visitEachChild(node, visitor, context);
+  };
+
+  return (sf: ts.SourceFile) => ts.visitNode(sf, visitor);
+}
+
+function afterTransformer(context: ts.TransformationContext): ts.Transformer<ts.SourceFile> {
+  const visitor: ts.Visitor = (node: ts.Node): ts.Node => {
+    // const flags = ts.getCombinedModifierFlags(node);
+    // const str = ts.ModifierFlags[flags];
+    // console.log(str);
+    return ts.visitEachChild(node, visitor, context);
+  };
+
+  return (sf: ts.SourceFile) => ts.visitNode(sf, visitor);
+}
+
+function check(diagnostics: ts.Diagnostic[]): void {
+  if (diagnostics && diagnostics.length > 0) {
+    bus.emit(messages.TS_COMPILER_DIAGNOSTICS, diagnostics);
+    console.error(ts.formatDiagnostics(diagnostics, {
+      getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
+      getNewLine: () => ts.sys.newLine,
+      getCanonicalFileName: (f: string) => f
+    }));
+  }
+}

From e28cd0819b9723f5420d428f2e0c1449bd5e5fec Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Wed, 15 Mar 2017 22:47:43 +0100
Subject: [PATCH 12/26] Util fixes and additions.

---
 src/next/util.ts | 21 ++++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

diff --git a/src/next/util.ts b/src/next/util.ts
index b95f859..1c6c17a 100644
--- a/src/next/util.ts
+++ b/src/next/util.ts
@@ -13,14 +13,29 @@ export function getScope(node: ts.Node): ts.Node {
     return node;
   }
 
-  if (this.isScope(node.kind)) {
+  if (isScopeKind(node.kind)) {
     return node;
   }
 
-  return this.getScope(node.parent);
+  return getScope(node.parent);
 }
 
-export function isScope(kind: ts.SyntaxKind): boolean {
+// TODO: test
+export function identifierExistsUp(node: ts.Node, id: string | ts.Identifier) {
+  if (typeof id !== 'string') id = id.text;
+  let current = node;
+  while (current.parent) current = current.parent;
+  return identifierExistsDown(current, id, node);
+}
+
+// TODO: test
+export function identifierExistsDown(node: ts.Node, id: string, stop?: ts.Node): boolean {
+  if (!node || node === stop) return false;
+  return node.kind === ts.SyntaxKind.Identifier && (node as ts.Identifier).text === id ?
+    true : !!ts.forEachChild(node, n => identifierExistsDown(n, id, stop));
+}
+
+export function isScopeKind(kind: ts.SyntaxKind): boolean {
   switch (kind) {
     case ts.SyntaxKind.SourceFile:
     case ts.SyntaxKind.Block:

From ec1c3a743d9f3e7fde6bd451931c866a52834ea9 Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Wed, 15 Mar 2017 22:48:37 +0100
Subject: [PATCH 13/26] Minor code style change.

---
 src/next/transform.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/next/transform.ts b/src/next/transform.ts
index a174c25..3da2637 100644
--- a/src/next/transform.ts
+++ b/src/next/transform.ts
@@ -143,7 +143,7 @@ function transformer(context: ts.TransformationContext): ts.Transformer<ts.Sourc
 
     if (DEBUG) {
       const scope = mutationContext.scope ? ts.SyntaxKind[mutationContext.scope.kind] : 'undefined';
-      console.log(`Visited: ${mutationContext.wasVisited(node) ? 'Yes' : 'No'}`)
+      console.log(`Visited: ${mutationContext.wasVisited(node) ? 'Yes' : 'No'}`);
       console.log(`Scope: ${scope}`);
       console.log(`Kind:  ${ts.SyntaxKind[node.kind]} (${node.kind})`);
       console.log(`File:  ${mutationContext.sourceFile.fileName}`);

From 5adb539241bf83dda503851a1d68ef3dff1306c4 Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Thu, 16 Mar 2017 22:21:15 +0100
Subject: [PATCH 14/26] Added binary expression mutator. Other improvements.

---
 src/next/mutators/BinaryExpressionMutator.ts  | 51 ++++++++++++++
 src/next/mutators/Mutator.ts                  |  4 ++
 .../VariableDeclarationListMutator.ts         | 70 ++++++++++++++-----
 3 files changed, 107 insertions(+), 18 deletions(-)
 create mode 100644 src/next/mutators/BinaryExpressionMutator.ts

diff --git a/src/next/mutators/BinaryExpressionMutator.ts b/src/next/mutators/BinaryExpressionMutator.ts
new file mode 100644
index 0000000..fab4bdd
--- /dev/null
+++ b/src/next/mutators/BinaryExpressionMutator.ts
@@ -0,0 +1,51 @@
+import * as ts from 'typescript';
+import * as generator from '../generator';
+import * as util from '../util';
+import { Mutator } from './Mutator';
+import { MutationContext } from '../context';
+
+export class BinaryExpressionMutator extends Mutator {
+
+  protected kind = ts.SyntaxKind.BinaryExpression;
+
+  private assignmentKinds: ts.SyntaxKind[] = [
+    ts.SyntaxKind.EqualsToken,
+    ts.SyntaxKind.PlusEqualsToken,
+    ts.SyntaxKind.MinusEqualsToken,
+    ts.SyntaxKind.AsteriskAsteriskEqualsToken,
+    ts.SyntaxKind.AsteriskEqualsToken,
+    ts.SyntaxKind.SlashEqualsToken,
+    ts.SyntaxKind.PercentEqualsToken,
+    ts.SyntaxKind.AmpersandEqualsToken,
+    ts.SyntaxKind.BarEqualsToken,
+    ts.SyntaxKind.CaretEqualsToken,
+    ts.SyntaxKind.LessThanLessThanEqualsToken,
+    ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken,
+    ts.SyntaxKind.GreaterThanGreaterThanEqualsToken,
+  ];
+
+  public mutate(node: ts.BinaryExpression): ts.Node {
+    if (this.assignmentKinds.indexOf(node.operatorToken.kind) === -1) {
+      return node;
+    }
+
+
+    if (node.left.kind !== ts.SyntaxKind.Identifier) {
+      return node;
+    }
+
+    const implicitType = this.context.getImplicitTypeNode(node.left);
+
+    if (!this.context.options.assertAny && implicitType.kind === ts.SyntaxKind.AnyKeyword) {
+      return node;
+    }
+
+    const nodeName = this.context.getTypeDeclarationName(node.left as ts.Identifier);
+    const right = generator.typeAssertion(nodeName, node.right);
+
+    this.context.addVisited(right, true, node.right);
+
+    return ts.updateBinary(node, node.left, right);
+  }
+
+}
diff --git a/src/next/mutators/Mutator.ts b/src/next/mutators/Mutator.ts
index a5454a4..0a91a12 100644
--- a/src/next/mutators/Mutator.ts
+++ b/src/next/mutators/Mutator.ts
@@ -8,7 +8,11 @@ export abstract class Mutator {
 
   protected abstract mutate(node: ts.Node, context?: MutationContext): ts.Node;
 
+  protected context: MutationContext;
+
   public mutateNode(node: ts.Node, context: MutationContext): ts.Node {
+    this.context = context;
+
     if (this.getKind().indexOf(node.kind) === -1) {
       return node;
     }
diff --git a/src/next/mutators/VariableDeclarationListMutator.ts b/src/next/mutators/VariableDeclarationListMutator.ts
index 32ba992..c18daab 100644
--- a/src/next/mutators/VariableDeclarationListMutator.ts
+++ b/src/next/mutators/VariableDeclarationListMutator.ts
@@ -1,5 +1,6 @@
 import * as ts from 'typescript';
 import * as generator from '../generator';
+import * as util from '../util';
 import { Mutator } from './Mutator';
 import { MutationContext } from '../context';
 
@@ -7,7 +8,7 @@ export class VariableDeclarationListMutator extends Mutator {
 
   protected kind = ts.SyntaxKind.VariableDeclarationList;
 
-  public mutate(node: ts.VariableDeclarationList, context: MutationContext): ts.Node {
+  public mutate(node: ts.VariableDeclarationList): ts.Node {
     if (!node.declarations) {
       return node;
     }
@@ -15,15 +16,15 @@ export class VariableDeclarationListMutator extends Mutator {
     const declarations: ts.VariableDeclaration[] = [];
 
     for (const declaration of node.declarations) {
-      const transformed = this.transformDeclaration(declaration, context);
-      transformed.forEach(n => context.addVisited(n, true));
+      const transformed = this.transform(declaration, this.context);
+      transformed.forEach(n => this.context.addVisited(n, true, n.initializer));
       declarations.push(...transformed);
     }
 
     return ts.updateVariableDeclarationList(node, declarations);
   }
 
-  private transformDeclaration(node: ts.VariableDeclaration, context: MutationContext): ts.VariableDeclaration[] {
+  private transform(node: ts.VariableDeclaration, context: MutationContext): ts.VariableDeclaration[] {
     if (context.wasVisited(node)) {
       return [node];
     }
@@ -35,49 +36,82 @@ export class VariableDeclarationListMutator extends Mutator {
         return this.transformUntypedConstDeclaration(node);
       }
 
-      return this.transformUntypedLetDeclaration(node);
+      return this.transformUntypedDeclaration(node);
     }
 
     if (isConst) {
       return this.transformConstDeclaration(node);
     }
 
-    return this.transformLetDeclaration(node);
+    return this.transformDeclaration(node);
   }
 
-  private transformLetDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] {
-    const nodeName = node.name.getText();
-    const typeDefinition = generator.typeDefinition(`_${nodeName}Type`, node.type);
+  private transformDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] {
+    if (!this.context.options.assertAny && node.type.kind === ts.SyntaxKind.AnyKeyword) {
+      return [node];
+    }
+
+    const nodeName = this.context.getTypeDeclarationName(node.name.getText());
+    const typeDefinition = generator.typeDeclaration(nodeName, node.type);
 
     if (!node.initializer) {
       return [typeDefinition, node];
     }
 
-    const initializer = generator.propertyAccessCall(`_${nodeName}Type`, 'assert', node.initializer);
+    const initializer = generator.typeAssertion(nodeName, node.initializer);
     const assignment = ts.updateVariableDeclaration(node, node.name, node.type, initializer);
 
     return [typeDefinition, assignment];
   }
 
   private transformConstDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] {
-    const nodeName = node.name.getText();
-    const typeCalls = generator.typeAssertion(node.type);
+    if (!this.context.options.assertAny && node.type.kind === ts.SyntaxKind.AnyKeyword) {
+      return [node];
+    }
 
-    const initializer = ts.createCall(
-      ts.createPropertyAccess(typeCalls, 'assert'), [], [node.initializer],
-    );
+    const nodeName = this.context.getTypeDeclarationName(node.name.getText());
 
+    const initializer = generator.typeDefinitionAndAssertion(node.type, node.initializer);
     const assignment = ts.updateVariableDeclaration(node, node.name, node.type, initializer);
 
     return [assignment];
   }
 
-  private transformUntypedLetDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] {
-    return [node];
+  private transformUntypedDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] {
+    const nodeName = this.context.getTypeDeclarationName(node.name.getText());
+    const implicitType = this.context.getImplicitTypeNode(node.name);
+
+    if (!this.context.options.assertAny && implicitType.kind === ts.SyntaxKind.AnyKeyword) {
+      return [node];
+    }
+
+    const typeDefinition = generator.typeDeclaration(
+      nodeName,
+      implicitType
+    );
+
+    if (!node.initializer) {
+      return [typeDefinition, node];
+    }
+
+    const initializer = generator.typeAssertion(nodeName, [node.initializer]);
+    const assignment = ts.updateVariableDeclaration(node, node.name, node.type, initializer);
+
+    return [typeDefinition, assignment];
   }
 
   private transformUntypedConstDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] {
-    return [node];
+    const nodeName = this.context.getTypeDeclarationName(node.name.getText());
+    const implicitType = this.context.getImplicitTypeNode(node.name);
+
+    if (!this.context.options.assertAny && implicitType.kind === ts.SyntaxKind.AnyKeyword) {
+      return [node];
+    }
+
+    const initializer = generator.typeDefinitionAndAssertion(implicitType, node.initializer);
+    const assignment = ts.updateVariableDeclaration(node, node.name, node.type, initializer);
+
+    return [assignment];
   }
 
 }

From 7004d0f485b46ddb82ded6f060060640dde96e43 Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Thu, 16 Mar 2017 22:22:33 +0100
Subject: [PATCH 15/26] Check implicit types. Added ability to get type of any
 identifier.

---
 src/next/context.ts   |  83 +++++++-
 src/next/generator.ts |  31 ++-
 src/next/mutators.ts  |   2 +
 src/next/options.ts   |   2 +
 src/next/transform.ts | 430 ++++++++++++++++++++++++++----------------
 5 files changed, 371 insertions(+), 177 deletions(-)

diff --git a/src/next/context.ts b/src/next/context.ts
index a0ce6d1..0b3a6dd 100644
--- a/src/next/context.ts
+++ b/src/next/context.ts
@@ -1,17 +1,27 @@
 import * as ts from 'typescript';
 import * as util from './util';
+import { Options } from './options';
 
 export type Scope = ts.SourceFile | ts.Block | ts.ModuleBlock | ts.CaseBlock;
 
 export class MutationContext {
 
+  private _options: Options;
   private _sourceFile: ts.SourceFile;
+  private _program: ts.Program;
+  private _checker: ts.TypeChecker;
+  private _host: ts.CompilerHost;
   private _scope: Scope;
   private _visited: ts.Node[];
   private _transformationContext: ts.TransformationContext;
 
-  constructor(sf?: ts.SourceFile) {
-    this._scope = sf;
+  constructor(options: Options, sourceFile: ts.SourceFile, program: ts.Program, host: ts.CompilerHost) {
+    this._options = options;
+    this._sourceFile = sourceFile;
+    this._program = program;
+    this._checker = program.getTypeChecker();
+    this._host = host;
+    this._scope = sourceFile;
     this._visited = [];
   }
 
@@ -23,8 +33,8 @@ export class MutationContext {
     return false;
   }
 
-  public addVisited(node: ts.Node, recursive = false): void {
-    if (!this.wasVisited(node)) {
+  public addVisited(node: ts.Node, recursive = false, ...exclude: ts.Node[]): void {
+    if (!this.wasVisited(node) && exclude.indexOf(node) === -1) {
       this._visited.push(node);
     }
 
@@ -46,18 +56,39 @@ export class MutationContext {
     return false;
   }
 
-  public setScope(node: ts.Node): void {
-    this.scope = node;
+  // TODO: implement
+  public getTypeDeclarationName(node: string | ts.BindingName): string {
+    const name = typeof node === 'string' ? node : node.getText();
+    return `_${name}Type`;
   }
 
-  public setTransformationContext(transformationContext: ts.TransformationContext): void {
-    this.transformationContext = transformationContext;
+  // TODO: implement
+  public getLibDeclarationName(): string {
+    return '';
   }
 
-  public setSourceFile(sourceFile: ts.Node): void {
-    this.sourceFile = sourceFile as ts.SourceFile;
+  public getImplicitTypeNode(node: ts.Node): ts.TypeNode {
+    let type = this.checker.getTypeAtLocation(node);
+    let typeString = this.checker.typeToString(type);
+    let source = `let temp: ${typeString};`;
+    let sf = ts.createSourceFile('temp', source, this.compilerOptions.target || ts.ScriptTarget.ES2015, true, ts.ScriptKind.TS);
+    return (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type;
+  }
+
+  public getType(node: ts.Node): ts.Type {
+    return this.checker.getTypeAtLocation(node);
   }
 
+  public getTypeFlag(node: ts.Node): ts.TypeFlags {
+    return this.getType(node).flags;
+  }
+
+  public getTypeFlagString(node: ts.Node): string {
+    return ts.TypeFlags[this.getTypeFlag(node)];
+  }
+
+  // getters and setters
+
   get transformationContext() {
     return this._transformationContext;
   }
@@ -66,6 +97,10 @@ export class MutationContext {
     this._transformationContext = transformationContext;
   }
 
+  public setTransformationContext(transformationContext: ts.TransformationContext): void {
+    this.transformationContext = transformationContext;
+  }
+
   get visited() {
     return this._visited;
   }
@@ -88,6 +123,10 @@ export class MutationContext {
     }
   }
 
+  public setScope(node: ts.Node): void {
+    this.scope = node;
+  }
+
   get sourceFile() {
     return this._sourceFile;
   }
@@ -100,4 +139,28 @@ export class MutationContext {
     this._sourceFile = sourceFile;
   }
 
+  public setSourceFile(sourceFile: ts.Node): void {
+    this.sourceFile = sourceFile as ts.SourceFile;
+  }
+
+  get compilerOptions() {
+    return this._options.compilerOptions;
+  }
+
+  get options() {
+    return this._options;
+  }
+
+  get program() {
+    return this._program;
+  }
+
+  get checker() {
+    return this._checker;
+  }
+
+  get host() {
+    return this._host;
+  }
+
 }
diff --git a/src/next/generator.ts b/src/next/generator.ts
index 69e4c62..dc7f10c 100644
--- a/src/next/generator.ts
+++ b/src/next/generator.ts
@@ -1,12 +1,29 @@
 import * as ts from 'typescript';
 
-export const LIB = 't';
+let LIB = 't';
 
-export function typeDefinition(name: string | ts.Identifier, type: string | ts.TypeNode): ts.VariableDeclaration {
-  return ts.createVariableDeclaration(name, undefined, typeAssertion(type));
+export function setLib(lib: string): void {
+  LIB = lib;
 }
 
-export function typeAssertion(type: ts.TypeNode | string): ts.CallExpression {
+export function getLib(): string {
+  return LIB;
+}
+
+export function typeDeclaration(name: string | ts.Identifier, type: string | ts.TypeNode): ts.VariableDeclaration {
+  return ts.createVariableDeclaration(name, undefined, typeDefinition(type));
+}
+
+export function typeDefinitionAndAssertion(type: string | ts.TypeNode, args: ts.Expression | ts.Expression[] = [], types: ts.TypeNode | ts.TypeNode[] = []): ts.CallExpression {
+  return typeAssertion(typeDefinition(type), args, types);
+}
+
+export function typeAssertion(id: string | ts.Expression, args: ts.Expression | ts.Expression[] = [], types: ts.TypeNode | ts.TypeNode[] = []): ts.CallExpression {
+  return propertyAccessCall(id, 'assert', args, types);
+}
+
+// TODO: Add ParenthesizedType (among others)
+export function typeDefinition(type: string | ts.TypeNode): ts.CallExpression {
   if (!type) {
     return null;
   }
@@ -28,7 +45,7 @@ export function typeAssertion(type: ts.TypeNode | string): ts.CallExpression {
     case ts.SyntaxKind.ArrayType:
       {
         const typeNode = (type as ts.ArrayTypeNode).elementType as ts.TypeNode;
-        const callExpression = propertyAccessCall(LIB, 'array', typeAssertion(typeNode));
+        const callExpression = propertyAccessCall(LIB, 'array', typeDefinition(typeNode));
         return callExpression;
       }
     case ts.SyntaxKind.TypeReference:
@@ -40,7 +57,7 @@ export function typeAssertion(type: ts.TypeNode | string): ts.CallExpression {
 
         if (typeRef.typeArguments) {
           for (const arg of typeRef.typeArguments) {
-            args.push(typeAssertion(arg));
+            args.push(typeDefinition(arg));
           }
         }
 
@@ -58,7 +75,7 @@ export function typeAssertion(type: ts.TypeNode | string): ts.CallExpression {
         const args: ts.CallExpression[] = [];
 
         for (const arg of typeRef.elementTypes) {
-          args.push(typeAssertion(arg));
+          args.push(typeDefinition(arg));
         }
 
         return propertyAccessCall(LIB, 'tuple', args);
diff --git a/src/next/mutators.ts b/src/next/mutators.ts
index 8b0c215..1d7b6dc 100644
--- a/src/next/mutators.ts
+++ b/src/next/mutators.ts
@@ -1,9 +1,11 @@
 import { Mutator } from './mutators/Mutator';
 
+import { BinaryExpressionMutator } from './mutators/BinaryExpressionMutator';
 import { InterfaceDeclarationMutator } from './mutators/InterfaceDeclararionMutator';
 import { VariableDeclarationListMutator } from './mutators/VariableDeclarationListMutator';
 
 export const mutators: Mutator[] = [
+  new BinaryExpressionMutator(),
   new InterfaceDeclarationMutator(),
   new VariableDeclarationListMutator(),
 ];
diff --git a/src/next/options.ts b/src/next/options.ts
index cba0e41..3c3387f 100644
--- a/src/next/options.ts
+++ b/src/next/options.ts
@@ -2,6 +2,7 @@ import * as ts from 'typescript';
 
 export interface Options {
   compilerOptions?: ts.CompilerOptions;
+  assertAny?: boolean;
   keepTempFiles?: boolean;
   tempFolderName?: string;
 }
@@ -12,6 +13,7 @@ export const defaultOptions: Options = {
     module: ts.ModuleKind.ES2015,
     target: ts.ScriptTarget.ES2015
   },
+  assertAny: false,
   keepTempFiles: true,
   tempFolderName: '.tsr'
 };
diff --git a/src/next/transform.ts b/src/next/transform.ts
index 3da2637..72a9982 100644
--- a/src/next/transform.ts
+++ b/src/next/transform.ts
@@ -7,222 +7,332 @@ import { MutationContext } from './context';
 import { mutators } from './mutators';
 import { Options, defaultOptions } from './options';
 
-const DEBUG = true;
+const DEBUG = false;
 
-export function transform(entryFile: string, options?: Options): void {
+export function transform(entryFile: string, options?: Options) {
   options = getOptions(options);
-  notify(bus.events.START, { entryFile, options });
 
-  const basePath = path.dirname(entryFile);
-  const host = ts.createCompilerHost(options.compilerOptions);
-  const program = ts.createProgram([entryFile], options.compilerOptions, host);
+  let host: ts.CompilerHost;
+  let program: ts.Program;
 
-  const diagnostics: ts.Diagnostic[] = [];
+  startTransformation();
 
-  diagnostics.push(...program.getOptionsDiagnostics());
-  diagnostics.push(...program.getGlobalDiagnostics());
+  function startTransformation(): void {
+    notify(bus.events.START, { entryFile, options });
 
-  for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) {
-    diagnostics.push(...program.getSyntacticDiagnostics(sourceFile));
-    diagnostics.push(...program.getSemanticDiagnostics(sourceFile));
-  }
-
-  if (!check(diagnostics)) {
-    notify(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics });
-    notify(bus.events.DIAGNOSTICS_TRANSFORM_PRE, { diagnostics });
-  }
+    const basePath = path.dirname(entryFile);
 
-  const sourceFiles = program.getSourceFiles().filter(sf => !sf.isDeclarationFile);
+    host = ts.createCompilerHost(options.compilerOptions);
+    program = ts.createProgram([entryFile], options.compilerOptions, host);
 
-  notify(bus.events.TRANSFORM_START, { sourceFiles });
-  const result = ts.transform(sourceFiles, [transformer], options.compilerOptions);
-  notify(bus.events.TRANSFORM_END, { sourceFiles: result.transformed });
+    const diagnostics: ts.Diagnostic[] = [];
 
-  if (!check(result.diagnostics)) {
-    notify(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics });
-    notify(bus.events.DIAGNOSTICS_TRANSFORM_POST, { diagnostics: result.diagnostics });
-  }
+    diagnostics.push(...program.getOptionsDiagnostics());
+    diagnostics.push(...program.getGlobalDiagnostics());
 
-  const printerOptions: ts.PrinterOptions = {
-    target: options.compilerOptions.target,
-    removeComments: false
-  };
-
-  const printHandlers: ts.PrintHandlers = {
-    substituteNode(hint: ts.EmitHint, node: ts.Node): ts.Node {
-      return node;
+    for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) {
+      diagnostics.push(...program.getSyntacticDiagnostics(sourceFile));
+      diagnostics.push(...program.getSemanticDiagnostics(sourceFile));
     }
-  };
-
-  notify(bus.events.WRITE_START, { count: result.transformed.length });
-  const printer = ts.createPrinter(printerOptions, printHandlers);
-
-  let count = 0;
-  for (let transformed of result.transformed) {
-    count++;
-    const location = toTempFilePath(transformed.fileName, basePath, options.tempFolderName);
-    const source = printer.printFile(transformed);
-    notify(bus.events.WRITE_FILE_START, { location, transformed, source });
-    ts.sys.writeFile(location, source);
-    notify(bus.events.WRITE_FILE_END, { location, transformed, source });
-  }
 
-  notify(bus.events.WRITE_END, { count });
+    if (!check(diagnostics)) {
+      notify(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics });
+      notify(bus.events.DIAGNOSTICS_TRANSFORM_PRE, { diagnostics });
+    }
 
-  result.dispose();
+    const sourceFiles = program.getSourceFiles().filter(sf => !sf.isDeclarationFile);
 
-  emit(entryFile, options);
+    notify(bus.events.TRANSFORM_START, { sourceFiles });
+    const result = ts.transform(sourceFiles, [transformer], options.compilerOptions);
+    notify(bus.events.TRANSFORM_END, { sourceFiles: result.transformed });
 
-  if (!options.keepTempFiles) {
-    const tempPath = getTempPath(basePath, options.tempFolderName);
-    notify(bus.events.TEMP_DELETE_START, { tempPath });
-    rimraf.sync(getTempPath(basePath, options.tempFolderName));
-    notify(bus.events.TEMP_DELETE_END, { tempPath });
-  }
+    if (!check(result.diagnostics)) {
+      notify(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics });
+      notify(bus.events.DIAGNOSTICS_TRANSFORM_POST, { diagnostics: result.diagnostics });
+    }
 
-  notify(bus.events.END, { entryFile, options });
-}
+    const printerOptions: ts.PrinterOptions = {
+      target: options.compilerOptions.target,
+      removeComments: false
+    };
 
-export function emit(entryFile: string, options: Options) {
-  const tempEntryFile = toTempFilePath(entryFile, path.dirname(entryFile), options.tempFolderName);
-  notify(bus.events.EMIT_START, { entryFile, tempEntryFile, options });
+    const printHandlers: ts.PrintHandlers = {
+      substituteNode(hint: ts.EmitHint, node: ts.Node): ts.Node {
+        return node;
+      }
+    };
+
+    notify(bus.events.WRITE_START, { count: result.transformed.length });
+    const printer = ts.createPrinter(printerOptions, printHandlers);
+
+    let count = 0;
+    for (let transformed of result.transformed) {
+      count++;
+      const location = toTempFilePath(transformed.fileName, basePath, options.tempFolderName);
+      const source = printer.printFile(transformed);
+      notify(bus.events.WRITE_FILE_START, { location, transformed, source });
+      ts.sys.writeFile(location, source);
+      notify(bus.events.WRITE_FILE_END, { location, transformed, source });
+    }
 
-  options.compilerOptions.outDir = path.dirname(entryFile);
+    notify(bus.events.WRITE_END, { count });
 
-  const host = ts.createCompilerHost(options.compilerOptions);
-  const program = ts.createProgram([tempEntryFile], options.compilerOptions, host);
+    result.dispose();
 
-  const diagnostics: ts.Diagnostic[] = [];
+    emit();
 
-  diagnostics.push(...program.getOptionsDiagnostics());
-  diagnostics.push(...program.getGlobalDiagnostics());
+    if (!options.keepTempFiles) {
+      const tempPath = getTempPath(basePath, options.tempFolderName);
+      notify(bus.events.TEMP_DELETE_START, { tempPath });
+      rimraf.sync(getTempPath(basePath, options.tempFolderName));
+      notify(bus.events.TEMP_DELETE_END, { tempPath });
+    }
 
-  for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) {
-    diagnostics.push(...program.getSyntacticDiagnostics(sourceFile));
-    diagnostics.push(...program.getSemanticDiagnostics(sourceFile));
+    notify(bus.events.END, { entryFile, options });
   }
 
+  function emit() {
+    const tempEntryFile = toTempFilePath(entryFile, path.dirname(entryFile), options.tempFolderName);
+    notify(bus.events.EMIT_START, { entryFile, tempEntryFile, options });
 
-  if (!check(diagnostics)) {
-    notify(bus.events.DIAGNOSTICS_EMIT, { diagnostics });
-    notify(bus.events.DIAGNOSTICS_EMIT_PRE, { diagnostics });
-  }
+    options.compilerOptions.outDir = path.dirname(entryFile);
 
-  const emitResult = program.emit();
+    host = ts.createCompilerHost(options.compilerOptions);
+    program = ts.createProgram([tempEntryFile], options.compilerOptions, host);
 
-  if (!check(emitResult.diagnostics)) {
-    notify(bus.events.DIAGNOSTICS_EMIT, { diagnostics: emitResult.diagnostics });
-    notify(bus.events.DIAGNOSTICS_EMIT_POST, { diagnostics: emitResult.diagnostics });
-  }
+    const diagnostics: ts.Diagnostic[] = [];
 
-  notify(bus.events.EMIT_END, { entryFile, tempEntryFile, options });
-}
+    diagnostics.push(...program.getOptionsDiagnostics());
+    diagnostics.push(...program.getGlobalDiagnostics());
 
-function onBeforeVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node {
-  if (util.isKind(node, ts.SyntaxKind.SourceFile)) {
-    mc.setSourceFile(node);
-  }
+    for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) {
+      diagnostics.push(...program.getSyntacticDiagnostics(sourceFile));
+      diagnostics.push(...program.getSemanticDiagnostics(sourceFile));
+    }
 
-  mc.setTransformationContext(tc);
-  mc.setScope(util.getScope(node));
 
-  return node;
-}
+    if (!check(diagnostics)) {
+      notify(bus.events.DIAGNOSTICS_EMIT, { diagnostics });
+      notify(bus.events.DIAGNOSTICS_EMIT_PRE, { diagnostics });
+    }
 
-function onAfterVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node {
-  mc.addVisited(node);
-  return node;
-}
+    const emitResult = program.emit();
 
-function transformer(context: ts.TransformationContext): ts.Transformer<ts.SourceFile> {
-  const mutationContext = new MutationContext();
+    if (!check(emitResult.diagnostics)) {
+      notify(bus.events.DIAGNOSTICS_EMIT, { diagnostics: emitResult.diagnostics });
+      notify(bus.events.DIAGNOSTICS_EMIT_POST, { diagnostics: emitResult.diagnostics });
+    }
 
-  const visitor: ts.Visitor = (node: ts.Node): ts.Node => {
-    const parent = node.parent;
-    node = onBeforeVisit(node, mutationContext, context);
+    notify(bus.events.EMIT_END, { entryFile, tempEntryFile, options });
+  }
 
-    if (DEBUG) {
-      const scope = mutationContext.scope ? ts.SyntaxKind[mutationContext.scope.kind] : 'undefined';
-      console.log(`Visited: ${mutationContext.wasVisited(node) ? 'Yes' : 'No'}`);
-      console.log(`Scope: ${scope}`);
-      console.log(`Kind:  ${ts.SyntaxKind[node.kind]} (${node.kind})`);
-      console.log(`File:  ${mutationContext.sourceFile.fileName}`);
+  function onBeforeVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node {
+    if (util.isKind(node, ts.SyntaxKind.SourceFile)) {
+      mc.setSourceFile(node);
     }
 
-    for (let mutator of mutators) {
-      node = mutator.mutateNode(node, mutationContext);
-    }
+    mc.setTransformationContext(tc);
+    mc.setScope(util.getScope(node));
+
+    return node;
+  }
+
+  function onAfterVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node {
+    mc.addVisited(node);
+    return node;
+  }
 
-    node.parent = parent;
-    util.setParent(node);
+  // function firstPassVisitor(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): void {
+  //   if (!node) return;
+  //   let checker = program.getTypeChecker();
+  //   ts.forEachChild(node, n => {
+  //
+  //
+  //     // let type = checker.getTypeAtLocation(n);
+  //     // // console.log('TYPE', type);
+  //     // let typeString = checker.typeToString(type);
+  //     // console.log('TYPESTRING', typeString);
+  //     // let source = `let temp: ${typeString};`;
+  //     // console.log('SRC', source);
+  //     // console.log('\n\n\n');
+  //     // let sf = ts.createSourceFile('temp', source, ts.ScriptTarget.ES2015);
+  //     // let typeNode = (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type;
+  //
+  //     switch (n.kind) {
+  //       case ts.SyntaxKind.BinaryExpression:
+  //         // console.log((n as ts.BinaryExpression).getText());
+  //         // let s = program.getTypeChecker().getSymbolAtLocation(n);
+  //         // let t = program.getTypeChecker().getContextualType(n as ts.BinaryExpression);
+  //         // console.log(s);
+  //         // console.log(t);
+  //         // console.log('\n\n');
+  //         break;
+  //       case ts.SyntaxKind.Identifier:
+  //         console.log((n as ts.Identifier).text);
+  //         console.log('-----------------------');
+  //
+  //
+  //
+  //         // let t = checker.getTypeAtLocation(n);
+  //         // // console.log(checker.getPropertiesOfType(t));
+  //         // // t = checker.getWidenedType(t);
+  //         // //
+  //         // console.log(ts.TypeFlags[t.flags]);
+  //
+  //         let type = checker.getTypeAtLocation(n);
+  //
+  //         let typeString = checker.typeToString(type);
+  //         console.log(typeString);
+  //         let source = `let temp: ${typeString};`;
+  //
+  //         let sf = ts.createSourceFile('temp', source, ts.ScriptTarget.ES2015);
+  //         let typeNode = (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type;
+  //
+  //         //
+  //         // let asm = type.aliasSymbol;
+  //         //
+  //         // if (asm) {
+  //         //   if (asm.declarations && asm.declarations[0]) {
+  //         //     console.log(asm.declarations.length);
+  //         //     let asmi = asm.declarations[0] as ts.VariableDeclaration;
+  //         //     if (asmi.type) {
+  //         //       console.log('has type');
+  //         //       console.log(ts.SyntaxKind[asmi.type.kind]);
+  //         //     }
+  //         //   }
+  //         // }
+  //         //
+  //         console.log(ts.TypeFlags[type.flags]);
+  //         console.log('\n\n');
+  //
+  //         // console.log('KIND:', (n as ts.Identifier).text);
+  //         // console.log((n as ts.Identifier).originalKeywordKind);
+  //         // console.log('');
+  //
+  //         // if (mc.names.indexOf((n as ts.Identifier).text) === -1) {
+  //         //   // mc.names.push((n as ts.Identifier).text);
+  //         //   // console.log('KIND:', (n as ts.Identifier).text);
+  //         //   // console.log((n as ts.Identifier).originalKeywordKind);
+  //         //   // console.log('');
+  //         // }
+  //         break;
+  //       case ts.SyntaxKind.VariableDeclaration:
+  //         // const dec = n as ts.VariableDeclaration;
+  //         // if (dec.name.kind === ts.SyntaxKind.Identifier) {
+  //         //   mc.declarations.set((dec.name as ts.Identifier).text, dec.type);
+  //         // }
+  //         break;
+  //     }
+  //
+  //     firstPassVisitor(n, mc, tc);
+  //   });
+  // }
+
+  function transformer(context: ts.TransformationContext): ts.Transformer<ts.SourceFile> {
+    let mutationContext: MutationContext;
+
+    const visitor: ts.Visitor = (node: ts.Node): ts.Node => {
+      if (node.kind === ts.SyntaxKind.SourceFile) {
+        mutationContext = new MutationContext(options, node as ts.SourceFile, program, host);
+        // firstPassVisitor(node as ts.SourceFile, mutationContext, context);
+      }
 
-    if (DEBUG) {
-      console.log('<============================================');
-      if (node.parent) {
-        if (node.flags === ts.NodeFlags.Synthesized) {
-          console.log('Cannot get text of synthesized node.');
+      // if (node.kind === ts.SyntaxKind.SourceFile) {
+      //   console.log('---------------');
+      //   console.log('SourceFile');
+      //   console.log((node as ts.SourceFile).fileName);
+      //   console.log('---------------\n\n');
+      // } else {
+      //   console.log(ts.SyntaxKind[node.kind]);
+      // }
+
+      const parent = node.parent;
+      node = onBeforeVisit(node, mutationContext, context);
+
+      if (DEBUG) {
+        const scope = mutationContext.scope ? ts.SyntaxKind[mutationContext.scope.kind] : 'undefined';
+        console.log(`Visited: ${mutationContext.wasVisited(node) ? 'Yes' : 'No'}`);
+        console.log(`Scope: ${scope}`);
+        console.log(`Kind:  ${ts.SyntaxKind[node.kind]} (${node.kind})`);
+        console.log(`File:  ${mutationContext.sourceFile.fileName}`);
+      }
+
+      for (let mutator of mutators) {
+        node = mutator.mutateNode(node, mutationContext);
+      }
+
+      node.parent = parent;
+      util.setParent(node);
+
+      if (DEBUG) {
+        console.log('<============================================');
+        if (node.parent) {
+          if (node.flags === ts.NodeFlags.Synthesized) {
+            console.log('Cannot get text of synthesized node.');
+          } else {
+            console.log(node.getText());
+          }
         } else {
-          console.log(node.getText());
+          console.log('Parent not set, cannot get text.');
         }
-      } else {
-        console.log('Parent not set, cannot get text.');
+        console.log('============================================>');
       }
-      console.log('============================================>');
-    }
 
 
-    if (DEBUG) {
-      console.log('\n\n');
-    }
+      if (DEBUG) {
+        console.log('\n\n');
+      }
 
-    node = onAfterVisit(node, mutationContext, context);
+      node = onAfterVisit(node, mutationContext, context);
 
-    return ts.visitEachChild(node, visitor, context);
-  };
+      return ts.visitEachChild(node, visitor, context);
+    };
 
-  return (sf: ts.SourceFile) => ts.visitNode(sf, visitor);
-}
+    return (sf: ts.SourceFile) => ts.visitNode(sf, visitor);
+  }
 
-function getOptions(options: Options = {}): Options {
-  const opts = Object.assign({}, defaultOptions, options);
-  opts.compilerOptions = Object.assign({}, defaultOptions.compilerOptions, options.compilerOptions || {});
-  return opts;
-}
+  function getOptions(o: Options = {}): Options {
+    const opts = Object.assign({}, defaultOptions, o);
+    opts.compilerOptions = Object.assign({}, defaultOptions.compilerOptions, o.compilerOptions || {});
+    return opts;
+  }
+
+  function getRootNames(rootNames: string | string[]): string[] {
+    if (Array.isArray(rootNames)) {
+      return rootNames;
+    }
 
-function getRootNames(rootNames: string | string[]): string[] {
-  if (Array.isArray(rootNames)) {
-    return rootNames;
+    return [rootNames];
   }
 
-  return [rootNames];
-}
+  function getTempPath(basePath: string, tempFolderName: string): string {
+    return path.join(basePath, tempFolderName);
+  }
 
-function getTempPath(basePath: string, tempFolderName: string): string {
-  return path.join(basePath, tempFolderName);
-}
+  function toTempFilePath(file: string, basePath: string, tempFolderName: string): string {
+    const pathFromBase = path.dirname(file.replace(basePath, ''));
+    const tempPath = getTempPath(basePath, tempFolderName);
+    const fileName = path.basename(file);
 
-function toTempFilePath(file: string, basePath: string, tempFolderName: string): string {
-  const pathFromBase = path.dirname(file.replace(basePath, ''));
-  const tempPath = getTempPath(basePath, tempFolderName);
-  const fileName = path.basename(file);
+    return path.join(tempPath, pathFromBase, fileName);
+  }
 
-  return path.join(tempPath, pathFromBase, fileName);
-}
+  function check(diagnostics: ts.Diagnostic[]): boolean {
+    if (diagnostics && diagnostics.length > 0) {
+      notify(bus.events.DIAGNOSTICS, { diagnostics });
+      console.error(ts.formatDiagnostics(diagnostics, {
+        getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
+        getNewLine: () => ts.sys.newLine,
+        getCanonicalFileName: (f: string) => f
+      }));
+      return false;
+    }
 
-function check(diagnostics: ts.Diagnostic[]): boolean {
-  if (diagnostics && diagnostics.length > 0) {
-    notify(bus.events.DIAGNOSTICS, { diagnostics });
-    console.error(ts.formatDiagnostics(diagnostics, {
-      getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
-      getNewLine: () => ts.sys.newLine,
-      getCanonicalFileName: (f: string) => f
-    }));
-    return false;
+    return true;
   }
 
-  return true;
-}
+  function notify(event: string | symbol, ...args: any[]): boolean {
+    return bus.emitter.emit(event, args);
+  }
 
-function notify(event: string | symbol, ...args: any[]): boolean {
-  return bus.emitter.emit(event, args);
 }

From dc0c571b8119e54b617ee5943b30dc23b8bb76b9 Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Thu, 16 Mar 2017 22:22:46 +0100
Subject: [PATCH 16/26] Changes to linter rules.

---
 tslint.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tslint.json b/tslint.json
index 4b8c6d7..ad5628a 100644
--- a/tslint.json
+++ b/tslint.json
@@ -22,7 +22,8 @@
     "array-type": false,
     "trailing-comma": false,
     "variable-name": false,
-    "no-conditional-assignment": false
+    "no-conditional-assignment": false,
+    "switch-default": false
   },
   "jsRules": {
 

From 9dab0f6df45a4dada34b1c1f2c11a259ec6e3a9c Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Thu, 16 Mar 2017 22:23:03 +0100
Subject: [PATCH 17/26] Temporary test output.

---
 src/test/v2/.tsr/source3.ts |  2 +-
 src/test/v2/.tsr/source4.ts | 18 ++++++++++++++++--
 src/test/v2/source3.js      |  2 +-
 src/test/v2/source4.js      | 18 ++++++++++++++++--
 src/test/v2/source4.ts      | 32 ++++++++++++++++++++++++++++----
 5 files changed, 62 insertions(+), 10 deletions(-)

diff --git a/src/test/v2/.tsr/source3.ts b/src/test/v2/.tsr/source3.ts
index c019563..39b6023 100644
--- a/src/test/v2/.tsr/source3.ts
+++ b/src/test/v2/.tsr/source3.ts
@@ -1 +1 @@
-export const bla = 'bla';
+export const bla = t.any().assert('bla');
diff --git a/src/test/v2/.tsr/source4.ts b/src/test/v2/.tsr/source4.ts
index 027a7c7..e58abd9 100644
--- a/src/test/v2/.tsr/source4.ts
+++ b/src/test/v2/.tsr/source4.ts
@@ -1,10 +1,24 @@
+import { bla } from './source3';
+console.log(bla);
 type TestType = {
     name: string;
 };
-const a: string = t.string().assert(10);
+const a: string = t.string().assert('hallo');
 let _bType = t.array(t.number()), b: number[];
-b = [a];
+b = _bType.assert([10]);
 function testFunction(t: TestType): string {
     return 'Hello ' + t.name;
 }
 console.log(testFunction({ name: 'Alice' }));
+let hasAnyType: any;
+hasAnyType = 55;
+const constAny: any = 10;
+let _xType = t.array(t.number()), x = _xType.assert([5, 10]);
+let hasNoType;
+hasNoType = 5;
+var _hiType = t.string(), hi: string;
+hi = _hiType.assert(console);
+const y = t.array(t.string()).assert(['hallo', 'du']);
+x = _xType.assert(5);
+x = _xType.assert('hi');
+hasNoType = 'str';
diff --git a/src/test/v2/source3.js b/src/test/v2/source3.js
index c019563..39b6023 100644
--- a/src/test/v2/source3.js
+++ b/src/test/v2/source3.js
@@ -1 +1 @@
-export const bla = 'bla';
+export const bla = t.any().assert('bla');
diff --git a/src/test/v2/source4.js b/src/test/v2/source4.js
index 4017790..838722f 100644
--- a/src/test/v2/source4.js
+++ b/src/test/v2/source4.js
@@ -1,7 +1,21 @@
-const a = t.string().assert(10);
+import { bla } from './source3';
+console.log(bla);
+const a = t.string().assert('hallo');
 let _bType = t.array(t.number()), b;
-b = [a];
+b = _bType.assert([10]);
 function testFunction(t) {
     return 'Hello ' + t.name;
 }
 console.log(testFunction({ name: 'Alice' }));
+let hasAnyType;
+hasAnyType = 55;
+const constAny = 10;
+let _xType = t.array(t.number()), x = _xType.assert([5, 10]);
+let hasNoType;
+hasNoType = 5;
+var _hiType = t.string(), hi;
+hi = _hiType.assert(console);
+const y = t.array(t.string()).assert(['hallo', 'du']);
+x = _xType.assert(5);
+x = _xType.assert('hi');
+hasNoType = 'str';
diff --git a/src/test/v2/source4.ts b/src/test/v2/source4.ts
index 4d5ad9f..e3fee78 100644
--- a/src/test/v2/source4.ts
+++ b/src/test/v2/source4.ts
@@ -1,13 +1,37 @@
+import { bla } from './source3';
+
+console.log(bla);
+
 type TestType = {
   name: string;
-}
+};
 
-const a: string = 10;
+const a: string = 'hallo';
 let b: number[];
-b = [a];
+b = [10];
 
-function testFunction (t: TestType): string {
+function testFunction(t: TestType): string {
   return 'Hello ' + t.name;
 }
 
 console.log(testFunction({name: 'Alice'}));
+
+let hasAnyType: any;
+hasAnyType = 55;
+
+const constAny: any = 10;
+
+let x = [5, 10];
+
+let hasNoType;
+hasNoType = 5;
+
+var hi: string;
+
+hi = console;
+
+const y = ['hallo', 'du'];
+
+x = 5;
+x = 'hi';
+hasNoType = 'str';

From 4fdb52d06697f48c0d4380427640a714624da031 Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Thu, 16 Mar 2017 23:32:36 +0100
Subject: [PATCH 18/26] Move next code to src.

---
 src/{ => _archived}/bin/handlers.ts           |   0
 src/{ => _archived}/bin/index.ts              |   0
 src/{ => _archived}/bin/status.ts             |   0
 .../src/bus.js => _archived/bus.ts}           |   0
 src/{ => _archived}/bus/Bus.ts                |   0
 src/{ => _archived}/compiler.ts               |   0
 src/{ => _archived}/compiler/Compiler.ts      |   0
 .../compiler/CompilerConfig.ts                |   0
 src/{ => _archived}/compiler/CompilerMode.ts  |   0
 .../compiler/CompilerResult.ts                |   0
 src/{ => _archived}/compiler/FileResult.ts    |   0
 .../compiler/_archive/generators.ts           |   0
 .../_archive/generators/class_definition.ts   |   0
 .../generators/interface_definition.ts        |   0
 .../_archive/generators/type_definition.ts    |   0
 .../generators/variable_assignment.ts         |   0
 .../compiler/_archive/utils.ts                |   0
 .../compiler/_archive/utils/ast.ts            |   0
 .../compiler/_archive/visitors.ts             |   0
 .../_archive/visitors/ClassVisitor.ts         |   0
 .../visitors/ExpressionStatementVisitor.ts    |   0
 .../_archive/visitors/InterfaceVisitor.js     |   0
 .../_archive/visitors/TypeParameterVisitor.ts |   0
 .../visitors/VariableDeclarationVisitor.ts    |   0
 .../visitors/VariableStatementVisitor.ts      |   0
 .../_archive/visitors/default_visitors.ts     |   0
 .../VariableDeclarationVisitor.ts             |   0
 .../compiler/_archive/visitors_new/Visitor.ts |   0
 .../_archive/visitors_new/default_visitors.ts |   0
 .../compiler/default_config.ts                |   0
 src/{ => _archived}/compiler/transformers.ts  |   0
 .../FunctionDeclarationTransformer.ts         |   0
 .../transformers/HasStatementsTransformer.ts  |   0
 .../compiler/transformers/Transformer.ts      |   0
 .../transformers/TransformerConfig.ts         |   0
 .../VariableDeclarationTransformer.ts         |   0
 .../compiler/transformers/default_config.ts   |   0
 .../transformers/default_transformers.ts      |   0
 src/{ => _archived}/compiler/utils.ts         |   0
 .../compiler/utils/generator.ts               |   0
 src/{ => _archived}/config.ts                 |   0
 src/{ => _archived}/config/Config.ts          |   0
 src/{ => _archived}/config/default_config.ts  |   0
 src/_archived/index.ts                        |   1 +
 src/{ => _archived}/lib/bundle.js             |   0
 src/{ => _archived}/lib/implement.js          |   0
 src/{ => _archived}/lib/implements.js         |   0
 src/{ => _archived}/lib/index.js              |   0
 src/{ => _archived}/lib/r.ts                  |   0
 src/{ => _archived}/lib/t.ts                  |   0
 .../Development/ts-runtime/src/bus.js         |   1 +
 .../Development/ts-runtime/src/compiler.js    |   0
 .../ts-runtime/src/compiler/Compiler.js       |   0
 src/{ => _archived}/playground/index.ts       |   0
 src/{ => _archived}/playground/package.json   |   0
 .../playground/simple_example.ts              |   0
 src/{ => _archived}/playground/test.js        |   0
 src/{ => _archived}/playground/test.ts        |   0
 src/{ => _archived}/playground/test0.js       |   0
 src/{ => _archived}/playground/test0.ts       |   0
 src/{ => _archived}/playground/test1.js       |   0
 src/{ => _archived}/playground/test1.ts       |   0
 src/{ => _archived}/playground/test2.js       |   0
 src/{ => _archived}/playground/test2.ts       |   0
 src/{ => _archived}/playground/test3.js       |   0
 src/{ => _archived}/playground/test3.ts       |   0
 src/{ => _archived}/playground/test4.js       |   0
 src/{ => _archived}/playground/test4.ts       |   0
 src/{ => _archived}/playground/yarn.lock      |   0
 .../test/config-2017-03-10_17-40-38-656.ts    |   0
 src/{ => _archived}/test/factory.ts           |   0
 src/{ => _archived}/test/source.js            |   0
 src/{ => _archived}/test/source.ts            |   0
 src/{ => _archived}/test/test.ts              |   0
 src/{ => _archived}/test/transformer.ts       |   0
 src/{ => _archived}/test/v1.ts                |   0
 src/{ => _archived}/test/v2/.tsr/source.ts    |   0
 src/{ => _archived}/test/v2/.tsr/source2.ts   |   0
 src/{ => _archived}/test/v2/.tsr/source3.ts   |   0
 src/{ => _archived}/test/v2/.tsr/source4.ts   |   0
 src/{ => _archived}/test/v2/source.js         |   0
 src/{ => _archived}/test/v2/source.ts         |   0
 src/{ => _archived}/test/v2/source2.js        |   0
 src/{ => _archived}/test/v2/source2.ts        |   0
 src/{ => _archived}/test/v2/source3.js        |   0
 src/{ => _archived}/test/v2/source3.ts        |   0
 src/{ => _archived}/test/v2/source4.js        |   0
 src/{ => _archived}/test/v2/source4.ts        |   0
 src/{ => _archived}/test/v2/test.ts           |   0
 src/{ => _archived}/test/v2/test2.ts          |   0
 src/{ => _archived}/test/v2/transform.old.ts  |   0
 src/_archived/transform.ts                    |  36 ++
 src/{ => _archived}/writer.ts                 |   0
 src/{ => _archived}/writer/Writer.ts          |   0
 src/{ => _archived}/writer/WriterConfig.ts    |   0
 src/{ => _archived}/writer/WriterResult.ts    |   0
 src/{ => _archived}/writer/default_config.ts  |   0
 src/bus.ts                                    |  29 +-
 src/{next => }/context.ts                     |   1 +
 src/{next => }/generator.ts                   |   0
 src/index.ts                                  |   7 +
 src/{next => }/mutators.ts                    |   8 +-
 .../mutators/BinaryExpressionMutator.ts       |   0
 .../mutators/InterfaceDeclararionMutator.ts   |   0
 src/{next => }/mutators/Mutator.ts            |   0
 .../VariableDeclarationListMutator.ts         |   4 +
 src/next/bus.ts                               |  28 --
 src/next/index.ts                             |  10 -
 src/next/transform.ts                         | 338 -----------------
 src/{next => }/options.ts                     |   0
 src/package.json                              |   5 -
 src/playground/run.ts                         |   6 +
 src/playground/snippets/.tsr/source3.ts       |  35 ++
 src/playground/snippets/.tsr/source4.ts       |  24 ++
 src/playground/snippets/source1.ts            |  15 +
 src/playground/snippets/source2.ts            |   5 +
 src/playground/snippets/source3.js            |  32 ++
 src/playground/snippets/source3.ts            |  55 +++
 src/playground/snippets/source4.js            |  21 ++
 src/playground/snippets/source4.ts            |  37 ++
 src/transform.ts                              | 352 ++++++++++++++++--
 src/{next => }/util.ts                        |   0
 src/yarn.lock                                 |  87 -----
 123 files changed, 642 insertions(+), 495 deletions(-)
 rename src/{ => _archived}/bin/handlers.ts (100%)
 rename src/{ => _archived}/bin/index.ts (100%)
 rename src/{ => _archived}/bin/status.ts (100%)
 rename src/{playground/Users/fabian/Documents/Development/ts-runtime/src/bus.js => _archived/bus.ts} (100%)
 rename src/{ => _archived}/bus/Bus.ts (100%)
 rename src/{ => _archived}/compiler.ts (100%)
 rename src/{ => _archived}/compiler/Compiler.ts (100%)
 rename src/{ => _archived}/compiler/CompilerConfig.ts (100%)
 rename src/{ => _archived}/compiler/CompilerMode.ts (100%)
 rename src/{ => _archived}/compiler/CompilerResult.ts (100%)
 rename src/{ => _archived}/compiler/FileResult.ts (100%)
 rename src/{ => _archived}/compiler/_archive/generators.ts (100%)
 rename src/{ => _archived}/compiler/_archive/generators/class_definition.ts (100%)
 rename src/{ => _archived}/compiler/_archive/generators/interface_definition.ts (100%)
 rename src/{ => _archived}/compiler/_archive/generators/type_definition.ts (100%)
 rename src/{ => _archived}/compiler/_archive/generators/variable_assignment.ts (100%)
 rename src/{ => _archived}/compiler/_archive/utils.ts (100%)
 rename src/{ => _archived}/compiler/_archive/utils/ast.ts (100%)
 rename src/{ => _archived}/compiler/_archive/visitors.ts (100%)
 rename src/{ => _archived}/compiler/_archive/visitors/ClassVisitor.ts (100%)
 rename src/{ => _archived}/compiler/_archive/visitors/ExpressionStatementVisitor.ts (100%)
 rename src/{ => _archived}/compiler/_archive/visitors/InterfaceVisitor.js (100%)
 rename src/{ => _archived}/compiler/_archive/visitors/TypeParameterVisitor.ts (100%)
 rename src/{ => _archived}/compiler/_archive/visitors/VariableDeclarationVisitor.ts (100%)
 rename src/{ => _archived}/compiler/_archive/visitors/VariableStatementVisitor.ts (100%)
 rename src/{ => _archived}/compiler/_archive/visitors/default_visitors.ts (100%)
 rename src/{ => _archived}/compiler/_archive/visitors_new/VariableDeclarationVisitor.ts (100%)
 rename src/{ => _archived}/compiler/_archive/visitors_new/Visitor.ts (100%)
 rename src/{ => _archived}/compiler/_archive/visitors_new/default_visitors.ts (100%)
 rename src/{ => _archived}/compiler/default_config.ts (100%)
 rename src/{ => _archived}/compiler/transformers.ts (100%)
 rename src/{ => _archived}/compiler/transformers/FunctionDeclarationTransformer.ts (100%)
 rename src/{ => _archived}/compiler/transformers/HasStatementsTransformer.ts (100%)
 rename src/{ => _archived}/compiler/transformers/Transformer.ts (100%)
 rename src/{ => _archived}/compiler/transformers/TransformerConfig.ts (100%)
 rename src/{ => _archived}/compiler/transformers/VariableDeclarationTransformer.ts (100%)
 rename src/{ => _archived}/compiler/transformers/default_config.ts (100%)
 rename src/{ => _archived}/compiler/transformers/default_transformers.ts (100%)
 rename src/{ => _archived}/compiler/utils.ts (100%)
 rename src/{ => _archived}/compiler/utils/generator.ts (100%)
 rename src/{ => _archived}/config.ts (100%)
 rename src/{ => _archived}/config/Config.ts (100%)
 rename src/{ => _archived}/config/default_config.ts (100%)
 create mode 100644 src/_archived/index.ts
 rename src/{ => _archived}/lib/bundle.js (100%)
 rename src/{ => _archived}/lib/implement.js (100%)
 rename src/{ => _archived}/lib/implements.js (100%)
 rename src/{ => _archived}/lib/index.js (100%)
 rename src/{ => _archived}/lib/r.ts (100%)
 rename src/{ => _archived}/lib/t.ts (100%)
 create mode 100644 src/_archived/playground/Users/fabian/Documents/Development/ts-runtime/src/bus.js
 rename src/{ => _archived}/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler.js (100%)
 rename src/{ => _archived}/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler/Compiler.js (100%)
 rename src/{ => _archived}/playground/index.ts (100%)
 rename src/{ => _archived}/playground/package.json (100%)
 rename src/{ => _archived}/playground/simple_example.ts (100%)
 rename src/{ => _archived}/playground/test.js (100%)
 rename src/{ => _archived}/playground/test.ts (100%)
 rename src/{ => _archived}/playground/test0.js (100%)
 rename src/{ => _archived}/playground/test0.ts (100%)
 rename src/{ => _archived}/playground/test1.js (100%)
 rename src/{ => _archived}/playground/test1.ts (100%)
 rename src/{ => _archived}/playground/test2.js (100%)
 rename src/{ => _archived}/playground/test2.ts (100%)
 rename src/{ => _archived}/playground/test3.js (100%)
 rename src/{ => _archived}/playground/test3.ts (100%)
 rename src/{ => _archived}/playground/test4.js (100%)
 rename src/{ => _archived}/playground/test4.ts (100%)
 rename src/{ => _archived}/playground/yarn.lock (100%)
 rename src/{ => _archived}/test/config-2017-03-10_17-40-38-656.ts (100%)
 rename src/{ => _archived}/test/factory.ts (100%)
 rename src/{ => _archived}/test/source.js (100%)
 rename src/{ => _archived}/test/source.ts (100%)
 rename src/{ => _archived}/test/test.ts (100%)
 rename src/{ => _archived}/test/transformer.ts (100%)
 rename src/{ => _archived}/test/v1.ts (100%)
 rename src/{ => _archived}/test/v2/.tsr/source.ts (100%)
 rename src/{ => _archived}/test/v2/.tsr/source2.ts (100%)
 rename src/{ => _archived}/test/v2/.tsr/source3.ts (100%)
 rename src/{ => _archived}/test/v2/.tsr/source4.ts (100%)
 rename src/{ => _archived}/test/v2/source.js (100%)
 rename src/{ => _archived}/test/v2/source.ts (100%)
 rename src/{ => _archived}/test/v2/source2.js (100%)
 rename src/{ => _archived}/test/v2/source2.ts (100%)
 rename src/{ => _archived}/test/v2/source3.js (100%)
 rename src/{ => _archived}/test/v2/source3.ts (100%)
 rename src/{ => _archived}/test/v2/source4.js (100%)
 rename src/{ => _archived}/test/v2/source4.ts (100%)
 rename src/{ => _archived}/test/v2/test.ts (100%)
 rename src/{ => _archived}/test/v2/test2.ts (100%)
 rename src/{ => _archived}/test/v2/transform.old.ts (100%)
 create mode 100644 src/_archived/transform.ts
 rename src/{ => _archived}/writer.ts (100%)
 rename src/{ => _archived}/writer/Writer.ts (100%)
 rename src/{ => _archived}/writer/WriterConfig.ts (100%)
 rename src/{ => _archived}/writer/WriterResult.ts (100%)
 rename src/{ => _archived}/writer/default_config.ts (100%)
 rename src/{next => }/context.ts (99%)
 rename src/{next => }/generator.ts (100%)
 rename src/{next => }/mutators.ts (79%)
 rename src/{next => }/mutators/BinaryExpressionMutator.ts (100%)
 rename src/{next => }/mutators/InterfaceDeclararionMutator.ts (100%)
 rename src/{next => }/mutators/Mutator.ts (100%)
 rename src/{next => }/mutators/VariableDeclarationListMutator.ts (97%)
 delete mode 100644 src/next/bus.ts
 delete mode 100644 src/next/index.ts
 delete mode 100644 src/next/transform.ts
 rename src/{next => }/options.ts (100%)
 delete mode 100644 src/package.json
 create mode 100644 src/playground/run.ts
 create mode 100644 src/playground/snippets/.tsr/source3.ts
 create mode 100644 src/playground/snippets/.tsr/source4.ts
 create mode 100644 src/playground/snippets/source1.ts
 create mode 100644 src/playground/snippets/source2.ts
 create mode 100644 src/playground/snippets/source3.js
 create mode 100644 src/playground/snippets/source3.ts
 create mode 100644 src/playground/snippets/source4.js
 create mode 100644 src/playground/snippets/source4.ts
 rename src/{next => }/util.ts (100%)
 delete mode 100644 src/yarn.lock

diff --git a/src/bin/handlers.ts b/src/_archived/bin/handlers.ts
similarity index 100%
rename from src/bin/handlers.ts
rename to src/_archived/bin/handlers.ts
diff --git a/src/bin/index.ts b/src/_archived/bin/index.ts
similarity index 100%
rename from src/bin/index.ts
rename to src/_archived/bin/index.ts
diff --git a/src/bin/status.ts b/src/_archived/bin/status.ts
similarity index 100%
rename from src/bin/status.ts
rename to src/_archived/bin/status.ts
diff --git a/src/playground/Users/fabian/Documents/Development/ts-runtime/src/bus.js b/src/_archived/bus.ts
similarity index 100%
rename from src/playground/Users/fabian/Documents/Development/ts-runtime/src/bus.js
rename to src/_archived/bus.ts
diff --git a/src/bus/Bus.ts b/src/_archived/bus/Bus.ts
similarity index 100%
rename from src/bus/Bus.ts
rename to src/_archived/bus/Bus.ts
diff --git a/src/compiler.ts b/src/_archived/compiler.ts
similarity index 100%
rename from src/compiler.ts
rename to src/_archived/compiler.ts
diff --git a/src/compiler/Compiler.ts b/src/_archived/compiler/Compiler.ts
similarity index 100%
rename from src/compiler/Compiler.ts
rename to src/_archived/compiler/Compiler.ts
diff --git a/src/compiler/CompilerConfig.ts b/src/_archived/compiler/CompilerConfig.ts
similarity index 100%
rename from src/compiler/CompilerConfig.ts
rename to src/_archived/compiler/CompilerConfig.ts
diff --git a/src/compiler/CompilerMode.ts b/src/_archived/compiler/CompilerMode.ts
similarity index 100%
rename from src/compiler/CompilerMode.ts
rename to src/_archived/compiler/CompilerMode.ts
diff --git a/src/compiler/CompilerResult.ts b/src/_archived/compiler/CompilerResult.ts
similarity index 100%
rename from src/compiler/CompilerResult.ts
rename to src/_archived/compiler/CompilerResult.ts
diff --git a/src/compiler/FileResult.ts b/src/_archived/compiler/FileResult.ts
similarity index 100%
rename from src/compiler/FileResult.ts
rename to src/_archived/compiler/FileResult.ts
diff --git a/src/compiler/_archive/generators.ts b/src/_archived/compiler/_archive/generators.ts
similarity index 100%
rename from src/compiler/_archive/generators.ts
rename to src/_archived/compiler/_archive/generators.ts
diff --git a/src/compiler/_archive/generators/class_definition.ts b/src/_archived/compiler/_archive/generators/class_definition.ts
similarity index 100%
rename from src/compiler/_archive/generators/class_definition.ts
rename to src/_archived/compiler/_archive/generators/class_definition.ts
diff --git a/src/compiler/_archive/generators/interface_definition.ts b/src/_archived/compiler/_archive/generators/interface_definition.ts
similarity index 100%
rename from src/compiler/_archive/generators/interface_definition.ts
rename to src/_archived/compiler/_archive/generators/interface_definition.ts
diff --git a/src/compiler/_archive/generators/type_definition.ts b/src/_archived/compiler/_archive/generators/type_definition.ts
similarity index 100%
rename from src/compiler/_archive/generators/type_definition.ts
rename to src/_archived/compiler/_archive/generators/type_definition.ts
diff --git a/src/compiler/_archive/generators/variable_assignment.ts b/src/_archived/compiler/_archive/generators/variable_assignment.ts
similarity index 100%
rename from src/compiler/_archive/generators/variable_assignment.ts
rename to src/_archived/compiler/_archive/generators/variable_assignment.ts
diff --git a/src/compiler/_archive/utils.ts b/src/_archived/compiler/_archive/utils.ts
similarity index 100%
rename from src/compiler/_archive/utils.ts
rename to src/_archived/compiler/_archive/utils.ts
diff --git a/src/compiler/_archive/utils/ast.ts b/src/_archived/compiler/_archive/utils/ast.ts
similarity index 100%
rename from src/compiler/_archive/utils/ast.ts
rename to src/_archived/compiler/_archive/utils/ast.ts
diff --git a/src/compiler/_archive/visitors.ts b/src/_archived/compiler/_archive/visitors.ts
similarity index 100%
rename from src/compiler/_archive/visitors.ts
rename to src/_archived/compiler/_archive/visitors.ts
diff --git a/src/compiler/_archive/visitors/ClassVisitor.ts b/src/_archived/compiler/_archive/visitors/ClassVisitor.ts
similarity index 100%
rename from src/compiler/_archive/visitors/ClassVisitor.ts
rename to src/_archived/compiler/_archive/visitors/ClassVisitor.ts
diff --git a/src/compiler/_archive/visitors/ExpressionStatementVisitor.ts b/src/_archived/compiler/_archive/visitors/ExpressionStatementVisitor.ts
similarity index 100%
rename from src/compiler/_archive/visitors/ExpressionStatementVisitor.ts
rename to src/_archived/compiler/_archive/visitors/ExpressionStatementVisitor.ts
diff --git a/src/compiler/_archive/visitors/InterfaceVisitor.js b/src/_archived/compiler/_archive/visitors/InterfaceVisitor.js
similarity index 100%
rename from src/compiler/_archive/visitors/InterfaceVisitor.js
rename to src/_archived/compiler/_archive/visitors/InterfaceVisitor.js
diff --git a/src/compiler/_archive/visitors/TypeParameterVisitor.ts b/src/_archived/compiler/_archive/visitors/TypeParameterVisitor.ts
similarity index 100%
rename from src/compiler/_archive/visitors/TypeParameterVisitor.ts
rename to src/_archived/compiler/_archive/visitors/TypeParameterVisitor.ts
diff --git a/src/compiler/_archive/visitors/VariableDeclarationVisitor.ts b/src/_archived/compiler/_archive/visitors/VariableDeclarationVisitor.ts
similarity index 100%
rename from src/compiler/_archive/visitors/VariableDeclarationVisitor.ts
rename to src/_archived/compiler/_archive/visitors/VariableDeclarationVisitor.ts
diff --git a/src/compiler/_archive/visitors/VariableStatementVisitor.ts b/src/_archived/compiler/_archive/visitors/VariableStatementVisitor.ts
similarity index 100%
rename from src/compiler/_archive/visitors/VariableStatementVisitor.ts
rename to src/_archived/compiler/_archive/visitors/VariableStatementVisitor.ts
diff --git a/src/compiler/_archive/visitors/default_visitors.ts b/src/_archived/compiler/_archive/visitors/default_visitors.ts
similarity index 100%
rename from src/compiler/_archive/visitors/default_visitors.ts
rename to src/_archived/compiler/_archive/visitors/default_visitors.ts
diff --git a/src/compiler/_archive/visitors_new/VariableDeclarationVisitor.ts b/src/_archived/compiler/_archive/visitors_new/VariableDeclarationVisitor.ts
similarity index 100%
rename from src/compiler/_archive/visitors_new/VariableDeclarationVisitor.ts
rename to src/_archived/compiler/_archive/visitors_new/VariableDeclarationVisitor.ts
diff --git a/src/compiler/_archive/visitors_new/Visitor.ts b/src/_archived/compiler/_archive/visitors_new/Visitor.ts
similarity index 100%
rename from src/compiler/_archive/visitors_new/Visitor.ts
rename to src/_archived/compiler/_archive/visitors_new/Visitor.ts
diff --git a/src/compiler/_archive/visitors_new/default_visitors.ts b/src/_archived/compiler/_archive/visitors_new/default_visitors.ts
similarity index 100%
rename from src/compiler/_archive/visitors_new/default_visitors.ts
rename to src/_archived/compiler/_archive/visitors_new/default_visitors.ts
diff --git a/src/compiler/default_config.ts b/src/_archived/compiler/default_config.ts
similarity index 100%
rename from src/compiler/default_config.ts
rename to src/_archived/compiler/default_config.ts
diff --git a/src/compiler/transformers.ts b/src/_archived/compiler/transformers.ts
similarity index 100%
rename from src/compiler/transformers.ts
rename to src/_archived/compiler/transformers.ts
diff --git a/src/compiler/transformers/FunctionDeclarationTransformer.ts b/src/_archived/compiler/transformers/FunctionDeclarationTransformer.ts
similarity index 100%
rename from src/compiler/transformers/FunctionDeclarationTransformer.ts
rename to src/_archived/compiler/transformers/FunctionDeclarationTransformer.ts
diff --git a/src/compiler/transformers/HasStatementsTransformer.ts b/src/_archived/compiler/transformers/HasStatementsTransformer.ts
similarity index 100%
rename from src/compiler/transformers/HasStatementsTransformer.ts
rename to src/_archived/compiler/transformers/HasStatementsTransformer.ts
diff --git a/src/compiler/transformers/Transformer.ts b/src/_archived/compiler/transformers/Transformer.ts
similarity index 100%
rename from src/compiler/transformers/Transformer.ts
rename to src/_archived/compiler/transformers/Transformer.ts
diff --git a/src/compiler/transformers/TransformerConfig.ts b/src/_archived/compiler/transformers/TransformerConfig.ts
similarity index 100%
rename from src/compiler/transformers/TransformerConfig.ts
rename to src/_archived/compiler/transformers/TransformerConfig.ts
diff --git a/src/compiler/transformers/VariableDeclarationTransformer.ts b/src/_archived/compiler/transformers/VariableDeclarationTransformer.ts
similarity index 100%
rename from src/compiler/transformers/VariableDeclarationTransformer.ts
rename to src/_archived/compiler/transformers/VariableDeclarationTransformer.ts
diff --git a/src/compiler/transformers/default_config.ts b/src/_archived/compiler/transformers/default_config.ts
similarity index 100%
rename from src/compiler/transformers/default_config.ts
rename to src/_archived/compiler/transformers/default_config.ts
diff --git a/src/compiler/transformers/default_transformers.ts b/src/_archived/compiler/transformers/default_transformers.ts
similarity index 100%
rename from src/compiler/transformers/default_transformers.ts
rename to src/_archived/compiler/transformers/default_transformers.ts
diff --git a/src/compiler/utils.ts b/src/_archived/compiler/utils.ts
similarity index 100%
rename from src/compiler/utils.ts
rename to src/_archived/compiler/utils.ts
diff --git a/src/compiler/utils/generator.ts b/src/_archived/compiler/utils/generator.ts
similarity index 100%
rename from src/compiler/utils/generator.ts
rename to src/_archived/compiler/utils/generator.ts
diff --git a/src/config.ts b/src/_archived/config.ts
similarity index 100%
rename from src/config.ts
rename to src/_archived/config.ts
diff --git a/src/config/Config.ts b/src/_archived/config/Config.ts
similarity index 100%
rename from src/config/Config.ts
rename to src/_archived/config/Config.ts
diff --git a/src/config/default_config.ts b/src/_archived/config/default_config.ts
similarity index 100%
rename from src/config/default_config.ts
rename to src/_archived/config/default_config.ts
diff --git a/src/_archived/index.ts b/src/_archived/index.ts
new file mode 100644
index 0000000..d5e7ab1
--- /dev/null
+++ b/src/_archived/index.ts
@@ -0,0 +1 @@
+export * from './transform';
diff --git a/src/lib/bundle.js b/src/_archived/lib/bundle.js
similarity index 100%
rename from src/lib/bundle.js
rename to src/_archived/lib/bundle.js
diff --git a/src/lib/implement.js b/src/_archived/lib/implement.js
similarity index 100%
rename from src/lib/implement.js
rename to src/_archived/lib/implement.js
diff --git a/src/lib/implements.js b/src/_archived/lib/implements.js
similarity index 100%
rename from src/lib/implements.js
rename to src/_archived/lib/implements.js
diff --git a/src/lib/index.js b/src/_archived/lib/index.js
similarity index 100%
rename from src/lib/index.js
rename to src/_archived/lib/index.js
diff --git a/src/lib/r.ts b/src/_archived/lib/r.ts
similarity index 100%
rename from src/lib/r.ts
rename to src/_archived/lib/r.ts
diff --git a/src/lib/t.ts b/src/_archived/lib/t.ts
similarity index 100%
rename from src/lib/t.ts
rename to src/_archived/lib/t.ts
diff --git a/src/_archived/playground/Users/fabian/Documents/Development/ts-runtime/src/bus.js b/src/_archived/playground/Users/fabian/Documents/Development/ts-runtime/src/bus.js
new file mode 100644
index 0000000..6ec1e45
--- /dev/null
+++ b/src/_archived/playground/Users/fabian/Documents/Development/ts-runtime/src/bus.js
@@ -0,0 +1 @@
+export { EventBus, bus } from './bus/Bus';
diff --git a/src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler.js b/src/_archived/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler.js
similarity index 100%
rename from src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler.js
rename to src/_archived/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler.js
diff --git a/src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler/Compiler.js b/src/_archived/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler/Compiler.js
similarity index 100%
rename from src/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler/Compiler.js
rename to src/_archived/playground/Users/fabian/Documents/Development/ts-runtime/src/compiler/Compiler.js
diff --git a/src/playground/index.ts b/src/_archived/playground/index.ts
similarity index 100%
rename from src/playground/index.ts
rename to src/_archived/playground/index.ts
diff --git a/src/playground/package.json b/src/_archived/playground/package.json
similarity index 100%
rename from src/playground/package.json
rename to src/_archived/playground/package.json
diff --git a/src/playground/simple_example.ts b/src/_archived/playground/simple_example.ts
similarity index 100%
rename from src/playground/simple_example.ts
rename to src/_archived/playground/simple_example.ts
diff --git a/src/playground/test.js b/src/_archived/playground/test.js
similarity index 100%
rename from src/playground/test.js
rename to src/_archived/playground/test.js
diff --git a/src/playground/test.ts b/src/_archived/playground/test.ts
similarity index 100%
rename from src/playground/test.ts
rename to src/_archived/playground/test.ts
diff --git a/src/playground/test0.js b/src/_archived/playground/test0.js
similarity index 100%
rename from src/playground/test0.js
rename to src/_archived/playground/test0.js
diff --git a/src/playground/test0.ts b/src/_archived/playground/test0.ts
similarity index 100%
rename from src/playground/test0.ts
rename to src/_archived/playground/test0.ts
diff --git a/src/playground/test1.js b/src/_archived/playground/test1.js
similarity index 100%
rename from src/playground/test1.js
rename to src/_archived/playground/test1.js
diff --git a/src/playground/test1.ts b/src/_archived/playground/test1.ts
similarity index 100%
rename from src/playground/test1.ts
rename to src/_archived/playground/test1.ts
diff --git a/src/playground/test2.js b/src/_archived/playground/test2.js
similarity index 100%
rename from src/playground/test2.js
rename to src/_archived/playground/test2.js
diff --git a/src/playground/test2.ts b/src/_archived/playground/test2.ts
similarity index 100%
rename from src/playground/test2.ts
rename to src/_archived/playground/test2.ts
diff --git a/src/playground/test3.js b/src/_archived/playground/test3.js
similarity index 100%
rename from src/playground/test3.js
rename to src/_archived/playground/test3.js
diff --git a/src/playground/test3.ts b/src/_archived/playground/test3.ts
similarity index 100%
rename from src/playground/test3.ts
rename to src/_archived/playground/test3.ts
diff --git a/src/playground/test4.js b/src/_archived/playground/test4.js
similarity index 100%
rename from src/playground/test4.js
rename to src/_archived/playground/test4.js
diff --git a/src/playground/test4.ts b/src/_archived/playground/test4.ts
similarity index 100%
rename from src/playground/test4.ts
rename to src/_archived/playground/test4.ts
diff --git a/src/playground/yarn.lock b/src/_archived/playground/yarn.lock
similarity index 100%
rename from src/playground/yarn.lock
rename to src/_archived/playground/yarn.lock
diff --git a/src/test/config-2017-03-10_17-40-38-656.ts b/src/_archived/test/config-2017-03-10_17-40-38-656.ts
similarity index 100%
rename from src/test/config-2017-03-10_17-40-38-656.ts
rename to src/_archived/test/config-2017-03-10_17-40-38-656.ts
diff --git a/src/test/factory.ts b/src/_archived/test/factory.ts
similarity index 100%
rename from src/test/factory.ts
rename to src/_archived/test/factory.ts
diff --git a/src/test/source.js b/src/_archived/test/source.js
similarity index 100%
rename from src/test/source.js
rename to src/_archived/test/source.js
diff --git a/src/test/source.ts b/src/_archived/test/source.ts
similarity index 100%
rename from src/test/source.ts
rename to src/_archived/test/source.ts
diff --git a/src/test/test.ts b/src/_archived/test/test.ts
similarity index 100%
rename from src/test/test.ts
rename to src/_archived/test/test.ts
diff --git a/src/test/transformer.ts b/src/_archived/test/transformer.ts
similarity index 100%
rename from src/test/transformer.ts
rename to src/_archived/test/transformer.ts
diff --git a/src/test/v1.ts b/src/_archived/test/v1.ts
similarity index 100%
rename from src/test/v1.ts
rename to src/_archived/test/v1.ts
diff --git a/src/test/v2/.tsr/source.ts b/src/_archived/test/v2/.tsr/source.ts
similarity index 100%
rename from src/test/v2/.tsr/source.ts
rename to src/_archived/test/v2/.tsr/source.ts
diff --git a/src/test/v2/.tsr/source2.ts b/src/_archived/test/v2/.tsr/source2.ts
similarity index 100%
rename from src/test/v2/.tsr/source2.ts
rename to src/_archived/test/v2/.tsr/source2.ts
diff --git a/src/test/v2/.tsr/source3.ts b/src/_archived/test/v2/.tsr/source3.ts
similarity index 100%
rename from src/test/v2/.tsr/source3.ts
rename to src/_archived/test/v2/.tsr/source3.ts
diff --git a/src/test/v2/.tsr/source4.ts b/src/_archived/test/v2/.tsr/source4.ts
similarity index 100%
rename from src/test/v2/.tsr/source4.ts
rename to src/_archived/test/v2/.tsr/source4.ts
diff --git a/src/test/v2/source.js b/src/_archived/test/v2/source.js
similarity index 100%
rename from src/test/v2/source.js
rename to src/_archived/test/v2/source.js
diff --git a/src/test/v2/source.ts b/src/_archived/test/v2/source.ts
similarity index 100%
rename from src/test/v2/source.ts
rename to src/_archived/test/v2/source.ts
diff --git a/src/test/v2/source2.js b/src/_archived/test/v2/source2.js
similarity index 100%
rename from src/test/v2/source2.js
rename to src/_archived/test/v2/source2.js
diff --git a/src/test/v2/source2.ts b/src/_archived/test/v2/source2.ts
similarity index 100%
rename from src/test/v2/source2.ts
rename to src/_archived/test/v2/source2.ts
diff --git a/src/test/v2/source3.js b/src/_archived/test/v2/source3.js
similarity index 100%
rename from src/test/v2/source3.js
rename to src/_archived/test/v2/source3.js
diff --git a/src/test/v2/source3.ts b/src/_archived/test/v2/source3.ts
similarity index 100%
rename from src/test/v2/source3.ts
rename to src/_archived/test/v2/source3.ts
diff --git a/src/test/v2/source4.js b/src/_archived/test/v2/source4.js
similarity index 100%
rename from src/test/v2/source4.js
rename to src/_archived/test/v2/source4.js
diff --git a/src/test/v2/source4.ts b/src/_archived/test/v2/source4.ts
similarity index 100%
rename from src/test/v2/source4.ts
rename to src/_archived/test/v2/source4.ts
diff --git a/src/test/v2/test.ts b/src/_archived/test/v2/test.ts
similarity index 100%
rename from src/test/v2/test.ts
rename to src/_archived/test/v2/test.ts
diff --git a/src/test/v2/test2.ts b/src/_archived/test/v2/test2.ts
similarity index 100%
rename from src/test/v2/test2.ts
rename to src/_archived/test/v2/test2.ts
diff --git a/src/test/v2/transform.old.ts b/src/_archived/test/v2/transform.old.ts
similarity index 100%
rename from src/test/v2/transform.old.ts
rename to src/_archived/test/v2/transform.old.ts
diff --git a/src/_archived/transform.ts b/src/_archived/transform.ts
new file mode 100644
index 0000000..79b588c
--- /dev/null
+++ b/src/_archived/transform.ts
@@ -0,0 +1,36 @@
+import * as ts from 'typescript';
+import { Compiler, CompilerResult, CompilerConfig } from './compiler';
+import { Config, DEFAULT_CONFIG } from './config';
+import { bus } from './bus';
+
+export function transform(files?: string | string[], config: Config = {}): Promise<CompilerResult> {
+  config = getConfig(config);
+  config.files = getFiles(files || config.files);
+
+  bus.emit('main.start', config.files);
+
+  return new Compiler(config)
+    .process()
+    .then(transformerResult => {
+      bus.emit('main.done', config.files);
+      return transformerResult;
+    });
+}
+
+function getConfig(config: Config = {}): Config {
+  return Object.assign({}, DEFAULT_CONFIG, config);
+}
+
+function getFiles(files: string | string[]): string[] {
+  if (typeof files === 'string') {
+    files = [files];
+  }
+
+  if (!Array.isArray(files)) {
+    bus.emit('error', new TypeError('Files passed to transform must be of type string[] or string.'));
+  }
+
+  return files as string[];
+}
+
+export default transform;
diff --git a/src/writer.ts b/src/_archived/writer.ts
similarity index 100%
rename from src/writer.ts
rename to src/_archived/writer.ts
diff --git a/src/writer/Writer.ts b/src/_archived/writer/Writer.ts
similarity index 100%
rename from src/writer/Writer.ts
rename to src/_archived/writer/Writer.ts
diff --git a/src/writer/WriterConfig.ts b/src/_archived/writer/WriterConfig.ts
similarity index 100%
rename from src/writer/WriterConfig.ts
rename to src/_archived/writer/WriterConfig.ts
diff --git a/src/writer/WriterResult.ts b/src/_archived/writer/WriterResult.ts
similarity index 100%
rename from src/writer/WriterResult.ts
rename to src/_archived/writer/WriterResult.ts
diff --git a/src/writer/default_config.ts b/src/_archived/writer/default_config.ts
similarity index 100%
rename from src/writer/default_config.ts
rename to src/_archived/writer/default_config.ts
diff --git a/src/bus.ts b/src/bus.ts
index 6ec1e45..602cfbd 100644
--- a/src/bus.ts
+++ b/src/bus.ts
@@ -1 +1,28 @@
-export { EventBus, bus } from './bus/Bus';
+import * as EventEmitter from 'events';
+
+export const events = {
+  START: Symbol('start'),
+  END: Symbol('end'),
+  DIAGNOSTICS: Symbol('ts.diagnostics'),
+  DIAGNOSTICS_TRANSFORM: Symbol('ts.diagnostics.transform'),
+  DIAGNOSTICS_TRANSFORM_PRE: Symbol('ts.diagnostics.transform.pre'),
+  DIAGNOSTICS_TRANSFORM_POST: Symbol('ts.diagnostics.transform.post'),
+  DIAGNOSTICS_EMIT: Symbol('ts.diagnostics.emit'),
+  DIAGNOSTICS_EMIT_PRE: Symbol('ts.diagnostics.emit.pre'),
+  DIAGNOSTICS_EMIT_POST: Symbol('ts.diagnostics.emit.post'),
+  TRANSFORM_START: Symbol('transform.start'),
+  TRANSFORM_END: Symbol('transform.end'),
+  // TRANSFORM_ERROR: Symbol('transform.error'),
+  WRITE_START: Symbol('write.start'),
+  WRITE_END: Symbol('write.end'),
+  WRITE_FILE_START: Symbol('write.file.start'),
+  WRITE_FILE_END: Symbol('write.file.end'),
+  // WRITE_ERROR: Symbol('write.error'),
+  EMIT_START: Symbol('emit.start'),
+  EMIT_END: Symbol('emit.end'),
+  // EMIT_ERROR: Symbol('emit.error'),
+  TEMP_DELETE_START: Symbol('temp.delete.start'),
+  TEMP_DELETE_END: Symbol('temp.delete.end'),
+};
+
+export const emitter = new EventEmitter();
diff --git a/src/next/context.ts b/src/context.ts
similarity index 99%
rename from src/next/context.ts
rename to src/context.ts
index 0b3a6dd..5e96159 100644
--- a/src/next/context.ts
+++ b/src/context.ts
@@ -67,6 +67,7 @@ export class MutationContext {
     return '';
   }
 
+  // TODO: primitive types fail sometimes
   public getImplicitTypeNode(node: ts.Node): ts.TypeNode {
     let type = this.checker.getTypeAtLocation(node);
     let typeString = this.checker.typeToString(type);
diff --git a/src/next/generator.ts b/src/generator.ts
similarity index 100%
rename from src/next/generator.ts
rename to src/generator.ts
diff --git a/src/index.ts b/src/index.ts
index d5e7ab1..718adf2 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1 +1,8 @@
+import * as bus from './bus';
+import * as util from './util';
+
+export { bus, util };
+export * from './context';
+export * from './mutators';
+export * from './options';
 export * from './transform';
diff --git a/src/next/mutators.ts b/src/mutators.ts
similarity index 79%
rename from src/next/mutators.ts
rename to src/mutators.ts
index 1d7b6dc..4baf69a 100644
--- a/src/next/mutators.ts
+++ b/src/mutators.ts
@@ -1,9 +1,15 @@
 import { Mutator } from './mutators/Mutator';
-
 import { BinaryExpressionMutator } from './mutators/BinaryExpressionMutator';
 import { InterfaceDeclarationMutator } from './mutators/InterfaceDeclararionMutator';
 import { VariableDeclarationListMutator } from './mutators/VariableDeclarationListMutator';
 
+export {
+  Mutator,
+  BinaryExpressionMutator,
+  InterfaceDeclarationMutator,
+  VariableDeclarationListMutator
+};
+
 export const mutators: Mutator[] = [
   new BinaryExpressionMutator(),
   new InterfaceDeclarationMutator(),
diff --git a/src/next/mutators/BinaryExpressionMutator.ts b/src/mutators/BinaryExpressionMutator.ts
similarity index 100%
rename from src/next/mutators/BinaryExpressionMutator.ts
rename to src/mutators/BinaryExpressionMutator.ts
diff --git a/src/next/mutators/InterfaceDeclararionMutator.ts b/src/mutators/InterfaceDeclararionMutator.ts
similarity index 100%
rename from src/next/mutators/InterfaceDeclararionMutator.ts
rename to src/mutators/InterfaceDeclararionMutator.ts
diff --git a/src/next/mutators/Mutator.ts b/src/mutators/Mutator.ts
similarity index 100%
rename from src/next/mutators/Mutator.ts
rename to src/mutators/Mutator.ts
diff --git a/src/next/mutators/VariableDeclarationListMutator.ts b/src/mutators/VariableDeclarationListMutator.ts
similarity index 97%
rename from src/next/mutators/VariableDeclarationListMutator.ts
rename to src/mutators/VariableDeclarationListMutator.ts
index c18daab..07187b8 100644
--- a/src/next/mutators/VariableDeclarationListMutator.ts
+++ b/src/mutators/VariableDeclarationListMutator.ts
@@ -102,7 +102,11 @@ export class VariableDeclarationListMutator extends Mutator {
 
   private transformUntypedConstDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] {
     const nodeName = this.context.getTypeDeclarationName(node.name.getText());
+
+    console.log(node.name.getText());
     const implicitType = this.context.getImplicitTypeNode(node.name);
+    console.log(ts.SyntaxKind[implicitType.kind]);
+    console.log('\n');
 
     if (!this.context.options.assertAny && implicitType.kind === ts.SyntaxKind.AnyKeyword) {
       return [node];
diff --git a/src/next/bus.ts b/src/next/bus.ts
deleted file mode 100644
index 602cfbd..0000000
--- a/src/next/bus.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import * as EventEmitter from 'events';
-
-export const events = {
-  START: Symbol('start'),
-  END: Symbol('end'),
-  DIAGNOSTICS: Symbol('ts.diagnostics'),
-  DIAGNOSTICS_TRANSFORM: Symbol('ts.diagnostics.transform'),
-  DIAGNOSTICS_TRANSFORM_PRE: Symbol('ts.diagnostics.transform.pre'),
-  DIAGNOSTICS_TRANSFORM_POST: Symbol('ts.diagnostics.transform.post'),
-  DIAGNOSTICS_EMIT: Symbol('ts.diagnostics.emit'),
-  DIAGNOSTICS_EMIT_PRE: Symbol('ts.diagnostics.emit.pre'),
-  DIAGNOSTICS_EMIT_POST: Symbol('ts.diagnostics.emit.post'),
-  TRANSFORM_START: Symbol('transform.start'),
-  TRANSFORM_END: Symbol('transform.end'),
-  // TRANSFORM_ERROR: Symbol('transform.error'),
-  WRITE_START: Symbol('write.start'),
-  WRITE_END: Symbol('write.end'),
-  WRITE_FILE_START: Symbol('write.file.start'),
-  WRITE_FILE_END: Symbol('write.file.end'),
-  // WRITE_ERROR: Symbol('write.error'),
-  EMIT_START: Symbol('emit.start'),
-  EMIT_END: Symbol('emit.end'),
-  // EMIT_ERROR: Symbol('emit.error'),
-  TEMP_DELETE_START: Symbol('temp.delete.start'),
-  TEMP_DELETE_END: Symbol('temp.delete.end'),
-};
-
-export const emitter = new EventEmitter();
diff --git a/src/next/index.ts b/src/next/index.ts
deleted file mode 100644
index 85a7872..0000000
--- a/src/next/index.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import * as b from './bus';
-export const bus = b;
-
-import * as u from './util';
-export const util = u;
-
-export * from './context';
-export * from './mutators';
-export * from './options';
-export * from './transform';
diff --git a/src/next/transform.ts b/src/next/transform.ts
deleted file mode 100644
index 72a9982..0000000
--- a/src/next/transform.ts
+++ /dev/null
@@ -1,338 +0,0 @@
-import * as path from 'path';
-import * as rimraf from 'rimraf';
-import * as ts from 'typescript';
-import * as util from './util';
-import * as bus from './bus';
-import { MutationContext } from './context';
-import { mutators } from './mutators';
-import { Options, defaultOptions } from './options';
-
-const DEBUG = false;
-
-export function transform(entryFile: string, options?: Options) {
-  options = getOptions(options);
-
-  let host: ts.CompilerHost;
-  let program: ts.Program;
-
-  startTransformation();
-
-  function startTransformation(): void {
-    notify(bus.events.START, { entryFile, options });
-
-    const basePath = path.dirname(entryFile);
-
-    host = ts.createCompilerHost(options.compilerOptions);
-    program = ts.createProgram([entryFile], options.compilerOptions, host);
-
-    const diagnostics: ts.Diagnostic[] = [];
-
-    diagnostics.push(...program.getOptionsDiagnostics());
-    diagnostics.push(...program.getGlobalDiagnostics());
-
-    for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) {
-      diagnostics.push(...program.getSyntacticDiagnostics(sourceFile));
-      diagnostics.push(...program.getSemanticDiagnostics(sourceFile));
-    }
-
-    if (!check(diagnostics)) {
-      notify(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics });
-      notify(bus.events.DIAGNOSTICS_TRANSFORM_PRE, { diagnostics });
-    }
-
-    const sourceFiles = program.getSourceFiles().filter(sf => !sf.isDeclarationFile);
-
-    notify(bus.events.TRANSFORM_START, { sourceFiles });
-    const result = ts.transform(sourceFiles, [transformer], options.compilerOptions);
-    notify(bus.events.TRANSFORM_END, { sourceFiles: result.transformed });
-
-    if (!check(result.diagnostics)) {
-      notify(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics });
-      notify(bus.events.DIAGNOSTICS_TRANSFORM_POST, { diagnostics: result.diagnostics });
-    }
-
-    const printerOptions: ts.PrinterOptions = {
-      target: options.compilerOptions.target,
-      removeComments: false
-    };
-
-    const printHandlers: ts.PrintHandlers = {
-      substituteNode(hint: ts.EmitHint, node: ts.Node): ts.Node {
-        return node;
-      }
-    };
-
-    notify(bus.events.WRITE_START, { count: result.transformed.length });
-    const printer = ts.createPrinter(printerOptions, printHandlers);
-
-    let count = 0;
-    for (let transformed of result.transformed) {
-      count++;
-      const location = toTempFilePath(transformed.fileName, basePath, options.tempFolderName);
-      const source = printer.printFile(transformed);
-      notify(bus.events.WRITE_FILE_START, { location, transformed, source });
-      ts.sys.writeFile(location, source);
-      notify(bus.events.WRITE_FILE_END, { location, transformed, source });
-    }
-
-    notify(bus.events.WRITE_END, { count });
-
-    result.dispose();
-
-    emit();
-
-    if (!options.keepTempFiles) {
-      const tempPath = getTempPath(basePath, options.tempFolderName);
-      notify(bus.events.TEMP_DELETE_START, { tempPath });
-      rimraf.sync(getTempPath(basePath, options.tempFolderName));
-      notify(bus.events.TEMP_DELETE_END, { tempPath });
-    }
-
-    notify(bus.events.END, { entryFile, options });
-  }
-
-  function emit() {
-    const tempEntryFile = toTempFilePath(entryFile, path.dirname(entryFile), options.tempFolderName);
-    notify(bus.events.EMIT_START, { entryFile, tempEntryFile, options });
-
-    options.compilerOptions.outDir = path.dirname(entryFile);
-
-    host = ts.createCompilerHost(options.compilerOptions);
-    program = ts.createProgram([tempEntryFile], options.compilerOptions, host);
-
-    const diagnostics: ts.Diagnostic[] = [];
-
-    diagnostics.push(...program.getOptionsDiagnostics());
-    diagnostics.push(...program.getGlobalDiagnostics());
-
-    for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) {
-      diagnostics.push(...program.getSyntacticDiagnostics(sourceFile));
-      diagnostics.push(...program.getSemanticDiagnostics(sourceFile));
-    }
-
-
-    if (!check(diagnostics)) {
-      notify(bus.events.DIAGNOSTICS_EMIT, { diagnostics });
-      notify(bus.events.DIAGNOSTICS_EMIT_PRE, { diagnostics });
-    }
-
-    const emitResult = program.emit();
-
-    if (!check(emitResult.diagnostics)) {
-      notify(bus.events.DIAGNOSTICS_EMIT, { diagnostics: emitResult.diagnostics });
-      notify(bus.events.DIAGNOSTICS_EMIT_POST, { diagnostics: emitResult.diagnostics });
-    }
-
-    notify(bus.events.EMIT_END, { entryFile, tempEntryFile, options });
-  }
-
-  function onBeforeVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node {
-    if (util.isKind(node, ts.SyntaxKind.SourceFile)) {
-      mc.setSourceFile(node);
-    }
-
-    mc.setTransformationContext(tc);
-    mc.setScope(util.getScope(node));
-
-    return node;
-  }
-
-  function onAfterVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node {
-    mc.addVisited(node);
-    return node;
-  }
-
-  // function firstPassVisitor(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): void {
-  //   if (!node) return;
-  //   let checker = program.getTypeChecker();
-  //   ts.forEachChild(node, n => {
-  //
-  //
-  //     // let type = checker.getTypeAtLocation(n);
-  //     // // console.log('TYPE', type);
-  //     // let typeString = checker.typeToString(type);
-  //     // console.log('TYPESTRING', typeString);
-  //     // let source = `let temp: ${typeString};`;
-  //     // console.log('SRC', source);
-  //     // console.log('\n\n\n');
-  //     // let sf = ts.createSourceFile('temp', source, ts.ScriptTarget.ES2015);
-  //     // let typeNode = (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type;
-  //
-  //     switch (n.kind) {
-  //       case ts.SyntaxKind.BinaryExpression:
-  //         // console.log((n as ts.BinaryExpression).getText());
-  //         // let s = program.getTypeChecker().getSymbolAtLocation(n);
-  //         // let t = program.getTypeChecker().getContextualType(n as ts.BinaryExpression);
-  //         // console.log(s);
-  //         // console.log(t);
-  //         // console.log('\n\n');
-  //         break;
-  //       case ts.SyntaxKind.Identifier:
-  //         console.log((n as ts.Identifier).text);
-  //         console.log('-----------------------');
-  //
-  //
-  //
-  //         // let t = checker.getTypeAtLocation(n);
-  //         // // console.log(checker.getPropertiesOfType(t));
-  //         // // t = checker.getWidenedType(t);
-  //         // //
-  //         // console.log(ts.TypeFlags[t.flags]);
-  //
-  //         let type = checker.getTypeAtLocation(n);
-  //
-  //         let typeString = checker.typeToString(type);
-  //         console.log(typeString);
-  //         let source = `let temp: ${typeString};`;
-  //
-  //         let sf = ts.createSourceFile('temp', source, ts.ScriptTarget.ES2015);
-  //         let typeNode = (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type;
-  //
-  //         //
-  //         // let asm = type.aliasSymbol;
-  //         //
-  //         // if (asm) {
-  //         //   if (asm.declarations && asm.declarations[0]) {
-  //         //     console.log(asm.declarations.length);
-  //         //     let asmi = asm.declarations[0] as ts.VariableDeclaration;
-  //         //     if (asmi.type) {
-  //         //       console.log('has type');
-  //         //       console.log(ts.SyntaxKind[asmi.type.kind]);
-  //         //     }
-  //         //   }
-  //         // }
-  //         //
-  //         console.log(ts.TypeFlags[type.flags]);
-  //         console.log('\n\n');
-  //
-  //         // console.log('KIND:', (n as ts.Identifier).text);
-  //         // console.log((n as ts.Identifier).originalKeywordKind);
-  //         // console.log('');
-  //
-  //         // if (mc.names.indexOf((n as ts.Identifier).text) === -1) {
-  //         //   // mc.names.push((n as ts.Identifier).text);
-  //         //   // console.log('KIND:', (n as ts.Identifier).text);
-  //         //   // console.log((n as ts.Identifier).originalKeywordKind);
-  //         //   // console.log('');
-  //         // }
-  //         break;
-  //       case ts.SyntaxKind.VariableDeclaration:
-  //         // const dec = n as ts.VariableDeclaration;
-  //         // if (dec.name.kind === ts.SyntaxKind.Identifier) {
-  //         //   mc.declarations.set((dec.name as ts.Identifier).text, dec.type);
-  //         // }
-  //         break;
-  //     }
-  //
-  //     firstPassVisitor(n, mc, tc);
-  //   });
-  // }
-
-  function transformer(context: ts.TransformationContext): ts.Transformer<ts.SourceFile> {
-    let mutationContext: MutationContext;
-
-    const visitor: ts.Visitor = (node: ts.Node): ts.Node => {
-      if (node.kind === ts.SyntaxKind.SourceFile) {
-        mutationContext = new MutationContext(options, node as ts.SourceFile, program, host);
-        // firstPassVisitor(node as ts.SourceFile, mutationContext, context);
-      }
-
-      // if (node.kind === ts.SyntaxKind.SourceFile) {
-      //   console.log('---------------');
-      //   console.log('SourceFile');
-      //   console.log((node as ts.SourceFile).fileName);
-      //   console.log('---------------\n\n');
-      // } else {
-      //   console.log(ts.SyntaxKind[node.kind]);
-      // }
-
-      const parent = node.parent;
-      node = onBeforeVisit(node, mutationContext, context);
-
-      if (DEBUG) {
-        const scope = mutationContext.scope ? ts.SyntaxKind[mutationContext.scope.kind] : 'undefined';
-        console.log(`Visited: ${mutationContext.wasVisited(node) ? 'Yes' : 'No'}`);
-        console.log(`Scope: ${scope}`);
-        console.log(`Kind:  ${ts.SyntaxKind[node.kind]} (${node.kind})`);
-        console.log(`File:  ${mutationContext.sourceFile.fileName}`);
-      }
-
-      for (let mutator of mutators) {
-        node = mutator.mutateNode(node, mutationContext);
-      }
-
-      node.parent = parent;
-      util.setParent(node);
-
-      if (DEBUG) {
-        console.log('<============================================');
-        if (node.parent) {
-          if (node.flags === ts.NodeFlags.Synthesized) {
-            console.log('Cannot get text of synthesized node.');
-          } else {
-            console.log(node.getText());
-          }
-        } else {
-          console.log('Parent not set, cannot get text.');
-        }
-        console.log('============================================>');
-      }
-
-
-      if (DEBUG) {
-        console.log('\n\n');
-      }
-
-      node = onAfterVisit(node, mutationContext, context);
-
-      return ts.visitEachChild(node, visitor, context);
-    };
-
-    return (sf: ts.SourceFile) => ts.visitNode(sf, visitor);
-  }
-
-  function getOptions(o: Options = {}): Options {
-    const opts = Object.assign({}, defaultOptions, o);
-    opts.compilerOptions = Object.assign({}, defaultOptions.compilerOptions, o.compilerOptions || {});
-    return opts;
-  }
-
-  function getRootNames(rootNames: string | string[]): string[] {
-    if (Array.isArray(rootNames)) {
-      return rootNames;
-    }
-
-    return [rootNames];
-  }
-
-  function getTempPath(basePath: string, tempFolderName: string): string {
-    return path.join(basePath, tempFolderName);
-  }
-
-  function toTempFilePath(file: string, basePath: string, tempFolderName: string): string {
-    const pathFromBase = path.dirname(file.replace(basePath, ''));
-    const tempPath = getTempPath(basePath, tempFolderName);
-    const fileName = path.basename(file);
-
-    return path.join(tempPath, pathFromBase, fileName);
-  }
-
-  function check(diagnostics: ts.Diagnostic[]): boolean {
-    if (diagnostics && diagnostics.length > 0) {
-      notify(bus.events.DIAGNOSTICS, { diagnostics });
-      console.error(ts.formatDiagnostics(diagnostics, {
-        getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
-        getNewLine: () => ts.sys.newLine,
-        getCanonicalFileName: (f: string) => f
-      }));
-      return false;
-    }
-
-    return true;
-  }
-
-  function notify(event: string | symbol, ...args: any[]): boolean {
-    return bus.emitter.emit(event, args);
-  }
-
-}
diff --git a/src/next/options.ts b/src/options.ts
similarity index 100%
rename from src/next/options.ts
rename to src/options.ts
diff --git a/src/package.json b/src/package.json
deleted file mode 100644
index ca9e77d..0000000
--- a/src/package.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-  "dependencies": {
-    "ora": "^1.1.0"
-  }
-}
diff --git a/src/playground/run.ts b/src/playground/run.ts
new file mode 100644
index 0000000..189bd12
--- /dev/null
+++ b/src/playground/run.ts
@@ -0,0 +1,6 @@
+import * as path from 'path';
+import * as tsr from '../';
+
+tsr.transform(path.join(__dirname, './snippets/source4.ts'), {
+  compilerOptions: {}
+});
diff --git a/src/playground/snippets/.tsr/source3.ts b/src/playground/snippets/.tsr/source3.ts
new file mode 100644
index 0000000..decbfde
--- /dev/null
+++ b/src/playground/snippets/.tsr/source3.ts
@@ -0,0 +1,35 @@
+export const bla = t.any().assert('bla');
+console.log(bla);
+type TestType = {
+    name: string;
+};
+const a: string = t.string().assert('hallo');
+let _bType = t.array(t.number()), b: number[];
+b = _bType.assert([10]);
+function testFunction(t: TestType): string {
+    return 'Hello ' + t.name;
+}
+console.log(testFunction({ name: 'Alice' }));
+let hasAnyType: any;
+hasAnyType = 55;
+const constAny: any = 10;
+function getX() {
+    return [1, 2, 3];
+}
+let _aaaType = t.number(), aaa = _aaaType.assert(10);
+const bbb = t.array(t.number()).assert(getX());
+let _xType = t.array(t.number()), x = _xType.assert([5, 10]);
+let hasNoType;
+hasNoType = 5;
+var _hiType = t.string(), hi: string;
+hi = _hiType.assert(console);
+const y = t.array(t.string()).assert(['hallo', 'du']);
+const z = t.any().assert('hhh');
+const h = t.array(t.number()).assert([1, 2]);
+x = _xType.assert(5);
+x = _xType.assert('hi');
+hasNoType = 'str';
+export const bla = t.array(t.number()).assert([10]);
+const blub = t.any().assert('str');
+let _wefkhType = t.number(), wefkh = _wefkhType.assert(111);
+x = _xType.assert(5);
diff --git a/src/playground/snippets/.tsr/source4.ts b/src/playground/snippets/.tsr/source4.ts
new file mode 100644
index 0000000..e58abd9
--- /dev/null
+++ b/src/playground/snippets/.tsr/source4.ts
@@ -0,0 +1,24 @@
+import { bla } from './source3';
+console.log(bla);
+type TestType = {
+    name: string;
+};
+const a: string = t.string().assert('hallo');
+let _bType = t.array(t.number()), b: number[];
+b = _bType.assert([10]);
+function testFunction(t: TestType): string {
+    return 'Hello ' + t.name;
+}
+console.log(testFunction({ name: 'Alice' }));
+let hasAnyType: any;
+hasAnyType = 55;
+const constAny: any = 10;
+let _xType = t.array(t.number()), x = _xType.assert([5, 10]);
+let hasNoType;
+hasNoType = 5;
+var _hiType = t.string(), hi: string;
+hi = _hiType.assert(console);
+const y = t.array(t.string()).assert(['hallo', 'du']);
+x = _xType.assert(5);
+x = _xType.assert('hi');
+hasNoType = 'str';
diff --git a/src/playground/snippets/source1.ts b/src/playground/snippets/source1.ts
new file mode 100644
index 0000000..4a84eb7
--- /dev/null
+++ b/src/playground/snippets/source1.ts
@@ -0,0 +1,15 @@
+import { a, TestInterface } from './source2';
+import { bla } from './source3';
+
+console.log(a);
+console.log(bla);
+console.log(TestInterface);
+
+class Test implements TestInterface {
+
+  public test(): string {
+    let a = 'hi';
+    return a;
+  }
+
+}
diff --git a/src/playground/snippets/source2.ts b/src/playground/snippets/source2.ts
new file mode 100644
index 0000000..888f0ea
--- /dev/null
+++ b/src/playground/snippets/source2.ts
@@ -0,0 +1,5 @@
+export interface TestInterface {
+
+}
+
+export const a = 'hi';
diff --git a/src/playground/snippets/source3.js b/src/playground/snippets/source3.js
new file mode 100644
index 0000000..84bd5ba
--- /dev/null
+++ b/src/playground/snippets/source3.js
@@ -0,0 +1,32 @@
+export const bla = t.any().assert('bla');
+console.log(bla);
+const a = t.string().assert('hallo');
+let _bType = t.array(t.number()), b;
+b = _bType.assert([10]);
+function testFunction(t) {
+    return 'Hello ' + t.name;
+}
+console.log(testFunction({ name: 'Alice' }));
+let hasAnyType;
+hasAnyType = 55;
+const constAny = 10;
+function getX() {
+    return [1, 2, 3];
+}
+let _aaaType = t.number(), aaa = _aaaType.assert(10);
+const bbb = t.array(t.number()).assert(getX());
+let _xType = t.array(t.number()), x = _xType.assert([5, 10]);
+let hasNoType;
+hasNoType = 5;
+var _hiType = t.string(), hi;
+hi = _hiType.assert(console);
+const y = t.array(t.string()).assert(['hallo', 'du']);
+const z = t.any().assert('hhh');
+const h = t.array(t.number()).assert([1, 2]);
+x = _xType.assert(5);
+x = _xType.assert('hi');
+hasNoType = 'str';
+export const bla = t.array(t.number()).assert([10]);
+const blub = t.any().assert('str');
+let _wefkhType = t.number(), wefkh = _wefkhType.assert(111);
+x = _xType.assert(5);
diff --git a/src/playground/snippets/source3.ts b/src/playground/snippets/source3.ts
new file mode 100644
index 0000000..5f34ef6
--- /dev/null
+++ b/src/playground/snippets/source3.ts
@@ -0,0 +1,55 @@
+export const bla = 'bla';
+
+console.log(bla);
+
+type TestType = {
+  name: string;
+};
+
+const a: string = 'hallo';
+let b: number[];
+b = [10];
+
+function testFunction(t: TestType): string {
+  return 'Hello ' + t.name;
+}
+
+console.log(testFunction({name: 'Alice'}));
+
+let hasAnyType: any;
+hasAnyType = 55;
+
+const constAny: any = 10;
+
+function getX() {
+  return [1, 2, 3];
+}
+
+let aaa = 10;
+const bbb = getX();
+let x = [5, 10];
+
+let hasNoType;
+hasNoType = 5;
+
+var hi: string;
+
+hi = console;
+
+const y = ['hallo', 'du'];
+
+const z = 'hhh';
+const h = [1, 2];
+
+x = 5;
+x = 'hi';
+hasNoType = 'str';
+
+export const bla = [10];
+
+const blub = 'str';
+
+let wefkh = 111;
+
+
+x = 5;
diff --git a/src/playground/snippets/source4.js b/src/playground/snippets/source4.js
new file mode 100644
index 0000000..838722f
--- /dev/null
+++ b/src/playground/snippets/source4.js
@@ -0,0 +1,21 @@
+import { bla } from './source3';
+console.log(bla);
+const a = t.string().assert('hallo');
+let _bType = t.array(t.number()), b;
+b = _bType.assert([10]);
+function testFunction(t) {
+    return 'Hello ' + t.name;
+}
+console.log(testFunction({ name: 'Alice' }));
+let hasAnyType;
+hasAnyType = 55;
+const constAny = 10;
+let _xType = t.array(t.number()), x = _xType.assert([5, 10]);
+let hasNoType;
+hasNoType = 5;
+var _hiType = t.string(), hi;
+hi = _hiType.assert(console);
+const y = t.array(t.string()).assert(['hallo', 'du']);
+x = _xType.assert(5);
+x = _xType.assert('hi');
+hasNoType = 'str';
diff --git a/src/playground/snippets/source4.ts b/src/playground/snippets/source4.ts
new file mode 100644
index 0000000..e3fee78
--- /dev/null
+++ b/src/playground/snippets/source4.ts
@@ -0,0 +1,37 @@
+import { bla } from './source3';
+
+console.log(bla);
+
+type TestType = {
+  name: string;
+};
+
+const a: string = 'hallo';
+let b: number[];
+b = [10];
+
+function testFunction(t: TestType): string {
+  return 'Hello ' + t.name;
+}
+
+console.log(testFunction({name: 'Alice'}));
+
+let hasAnyType: any;
+hasAnyType = 55;
+
+const constAny: any = 10;
+
+let x = [5, 10];
+
+let hasNoType;
+hasNoType = 5;
+
+var hi: string;
+
+hi = console;
+
+const y = ['hallo', 'du'];
+
+x = 5;
+x = 'hi';
+hasNoType = 'str';
diff --git a/src/transform.ts b/src/transform.ts
index 79b588c..bb212a3 100644
--- a/src/transform.ts
+++ b/src/transform.ts
@@ -1,36 +1,338 @@
+import * as path from 'path';
+import * as rimraf from 'rimraf';
 import * as ts from 'typescript';
-import { Compiler, CompilerResult, CompilerConfig } from './compiler';
-import { Config, DEFAULT_CONFIG } from './config';
-import { bus } from './bus';
-
-export function transform(files?: string | string[], config: Config = {}): Promise<CompilerResult> {
-  config = getConfig(config);
-  config.files = getFiles(files || config.files);
-
-  bus.emit('main.start', config.files);
-
-  return new Compiler(config)
-    .process()
-    .then(transformerResult => {
-      bus.emit('main.done', config.files);
-      return transformerResult;
-    });
+import * as util from './util';
+import * as bus from './bus';
+import { MutationContext } from './context';
+import { mutators } from './mutators';
+import { Options, defaultOptions } from './options';
+
+const DEBUG = false;
+
+export function transform(entryFile: string, options?: Options) {
+  options = getOptions(options);
+
+  let host: ts.CompilerHost;
+  let program: ts.Program;
+
+  startTransformation();
+
+  function startTransformation(): void {
+    notify(bus.events.START, { entryFile, options });
+
+    const basePath = path.dirname(entryFile);
+
+    host = ts.createCompilerHost(options.compilerOptions, true);
+    program = ts.createProgram([entryFile], options.compilerOptions, host);
+
+    const diagnostics: ts.Diagnostic[] = [];
+
+    diagnostics.push(...program.getOptionsDiagnostics());
+    diagnostics.push(...program.getGlobalDiagnostics());
+
+    for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) {
+      diagnostics.push(...program.getSyntacticDiagnostics(sourceFile));
+      diagnostics.push(...program.getSemanticDiagnostics(sourceFile));
+    }
+
+    if (!check(diagnostics)) {
+      notify(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics });
+      notify(bus.events.DIAGNOSTICS_TRANSFORM_PRE, { diagnostics });
+    }
+
+    const sourceFiles = program.getSourceFiles().filter(sf => !sf.isDeclarationFile);
+
+    notify(bus.events.TRANSFORM_START, { sourceFiles });
+    const result = ts.transform(sourceFiles, [transformer], options.compilerOptions);
+    notify(bus.events.TRANSFORM_END, { sourceFiles: result.transformed });
+
+    if (!check(result.diagnostics)) {
+      notify(bus.events.DIAGNOSTICS_TRANSFORM, { diagnostics });
+      notify(bus.events.DIAGNOSTICS_TRANSFORM_POST, { diagnostics: result.diagnostics });
+    }
+
+    const printerOptions: ts.PrinterOptions = {
+      target: options.compilerOptions.target,
+      removeComments: false
+    };
+
+    const printHandlers: ts.PrintHandlers = {
+      substituteNode(hint: ts.EmitHint, node: ts.Node): ts.Node {
+        return node;
+      }
+    };
+
+    notify(bus.events.WRITE_START, { count: result.transformed.length });
+    const printer = ts.createPrinter(printerOptions, printHandlers);
+
+    let count = 0;
+    for (let transformed of result.transformed) {
+      count++;
+      const location = toTempFilePath(transformed.fileName, basePath, options.tempFolderName);
+      const source = printer.printFile(transformed);
+      notify(bus.events.WRITE_FILE_START, { location, transformed, source });
+      ts.sys.writeFile(location, source);
+      notify(bus.events.WRITE_FILE_END, { location, transformed, source });
+    }
+
+    notify(bus.events.WRITE_END, { count });
+
+    result.dispose();
+
+    emit();
+
+    if (!options.keepTempFiles) {
+      const tempPath = getTempPath(basePath, options.tempFolderName);
+      notify(bus.events.TEMP_DELETE_START, { tempPath });
+      rimraf.sync(getTempPath(basePath, options.tempFolderName));
+      notify(bus.events.TEMP_DELETE_END, { tempPath });
+    }
+
+    notify(bus.events.END, { entryFile, options });
+  }
+
+  function emit() {
+    const tempEntryFile = toTempFilePath(entryFile, path.dirname(entryFile), options.tempFolderName);
+    notify(bus.events.EMIT_START, { entryFile, tempEntryFile, options });
+
+    options.compilerOptions.outDir = path.dirname(entryFile);
+
+    host = ts.createCompilerHost(options.compilerOptions);
+    program = ts.createProgram([tempEntryFile], options.compilerOptions, host);
+
+    const diagnostics: ts.Diagnostic[] = [];
+
+    diagnostics.push(...program.getOptionsDiagnostics());
+    diagnostics.push(...program.getGlobalDiagnostics());
+
+    for (let sourceFile of program.getSourceFiles().filter(sf => !/\.d\.ts$/.test(sf.fileName))) {
+      diagnostics.push(...program.getSyntacticDiagnostics(sourceFile));
+      diagnostics.push(...program.getSemanticDiagnostics(sourceFile));
+    }
+
+
+    if (!check(diagnostics)) {
+      notify(bus.events.DIAGNOSTICS_EMIT, { diagnostics });
+      notify(bus.events.DIAGNOSTICS_EMIT_PRE, { diagnostics });
+    }
+
+    const emitResult = program.emit();
+
+    if (!check(emitResult.diagnostics)) {
+      notify(bus.events.DIAGNOSTICS_EMIT, { diagnostics: emitResult.diagnostics });
+      notify(bus.events.DIAGNOSTICS_EMIT_POST, { diagnostics: emitResult.diagnostics });
+    }
+
+    notify(bus.events.EMIT_END, { entryFile, tempEntryFile, options });
+  }
+
+  function onBeforeVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node {
+    if (util.isKind(node, ts.SyntaxKind.SourceFile)) {
+      mc.setSourceFile(node);
+    }
+
+    mc.setTransformationContext(tc);
+    mc.setScope(util.getScope(node));
+
+    return node;
+  }
+
+  function onAfterVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node {
+    mc.addVisited(node);
+    return node;
+  }
+
+  // function firstPassVisitor(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): void {
+  //   if (!node) return;
+  //   let checker = program.getTypeChecker();
+  //   ts.forEachChild(node, n => {
+  //
+  //
+  //     // let type = checker.getTypeAtLocation(n);
+  //     // // console.log('TYPE', type);
+  //     // let typeString = checker.typeToString(type);
+  //     // console.log('TYPESTRING', typeString);
+  //     // let source = `let temp: ${typeString};`;
+  //     // console.log('SRC', source);
+  //     // console.log('\n\n\n');
+  //     // let sf = ts.createSourceFile('temp', source, ts.ScriptTarget.ES2015);
+  //     // let typeNode = (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type;
+  //
+  //     switch (n.kind) {
+  //       case ts.SyntaxKind.BinaryExpression:
+  //         // console.log((n as ts.BinaryExpression).getText());
+  //         // let s = program.getTypeChecker().getSymbolAtLocation(n);
+  //         // let t = program.getTypeChecker().getContextualType(n as ts.BinaryExpression);
+  //         // console.log(s);
+  //         // console.log(t);
+  //         // console.log('\n\n');
+  //         break;
+  //       case ts.SyntaxKind.Identifier:
+  //         console.log((n as ts.Identifier).text);
+  //         console.log('-----------------------');
+  //
+  //
+  //
+  //         // let t = checker.getTypeAtLocation(n);
+  //         // // console.log(checker.getPropertiesOfType(t));
+  //         // // t = checker.getWidenedType(t);
+  //         // //
+  //         // console.log(ts.TypeFlags[t.flags]);
+  //
+  //         let type = checker.getTypeAtLocation(n);
+  //
+  //         let typeString = checker.typeToString(type);
+  //         console.log(typeString);
+  //         let source = `let temp: ${typeString};`;
+  //
+  //         let sf = ts.createSourceFile('temp', source, ts.ScriptTarget.ES2015);
+  //         let typeNode = (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type;
+  //
+  //         //
+  //         // let asm = type.aliasSymbol;
+  //         //
+  //         // if (asm) {
+  //         //   if (asm.declarations && asm.declarations[0]) {
+  //         //     console.log(asm.declarations.length);
+  //         //     let asmi = asm.declarations[0] as ts.VariableDeclaration;
+  //         //     if (asmi.type) {
+  //         //       console.log('has type');
+  //         //       console.log(ts.SyntaxKind[asmi.type.kind]);
+  //         //     }
+  //         //   }
+  //         // }
+  //         //
+  //         console.log(ts.TypeFlags[type.flags]);
+  //         console.log('\n\n');
+  //
+  //         // console.log('KIND:', (n as ts.Identifier).text);
+  //         // console.log((n as ts.Identifier).originalKeywordKind);
+  //         // console.log('');
+  //
+  //         // if (mc.names.indexOf((n as ts.Identifier).text) === -1) {
+  //         //   // mc.names.push((n as ts.Identifier).text);
+  //         //   // console.log('KIND:', (n as ts.Identifier).text);
+  //         //   // console.log((n as ts.Identifier).originalKeywordKind);
+  //         //   // console.log('');
+  //         // }
+  //         break;
+  //       case ts.SyntaxKind.VariableDeclaration:
+  //         // const dec = n as ts.VariableDeclaration;
+  //         // if (dec.name.kind === ts.SyntaxKind.Identifier) {
+  //         //   mc.declarations.set((dec.name as ts.Identifier).text, dec.type);
+  //         // }
+  //         break;
+  //     }
+  //
+  //     firstPassVisitor(n, mc, tc);
+  //   });
+  // }
+
+  function transformer(context: ts.TransformationContext): ts.Transformer<ts.SourceFile> {
+    let mutationContext: MutationContext;
+
+    const visitor: ts.Visitor = (node: ts.Node): ts.Node => {
+      if (node.kind === ts.SyntaxKind.SourceFile) {
+        mutationContext = new MutationContext(options, node as ts.SourceFile, program, host);
+        // firstPassVisitor(node as ts.SourceFile, mutationContext, context);
+      }
+
+      // if (node.kind === ts.SyntaxKind.SourceFile) {
+      //   console.log('---------------');
+      //   console.log('SourceFile');
+      //   console.log((node as ts.SourceFile).fileName);
+      //   console.log('---------------\n\n');
+      // } else {
+      //   console.log(ts.SyntaxKind[node.kind]);
+      // }
+
+      const parent = node.parent;
+      node = onBeforeVisit(node, mutationContext, context);
+
+      if (DEBUG) {
+        const scope = mutationContext.scope ? ts.SyntaxKind[mutationContext.scope.kind] : 'undefined';
+        console.log(`Visited: ${mutationContext.wasVisited(node) ? 'Yes' : 'No'}`);
+        console.log(`Scope: ${scope}`);
+        console.log(`Kind:  ${ts.SyntaxKind[node.kind]} (${node.kind})`);
+        console.log(`File:  ${mutationContext.sourceFile.fileName}`);
+      }
+
+      for (let mutator of mutators) {
+        node = mutator.mutateNode(node, mutationContext);
+      }
+
+      node.parent = parent;
+      util.setParent(node);
+
+      if (DEBUG) {
+        console.log('<============================================');
+        if (node.parent) {
+          if (node.flags === ts.NodeFlags.Synthesized) {
+            console.log('Cannot get text of synthesized node.');
+          } else {
+            console.log(node.getText());
+          }
+        } else {
+          console.log('Parent not set, cannot get text.');
+        }
+        console.log('============================================>');
+      }
+
+
+      if (DEBUG) {
+        console.log('\n\n');
+      }
+
+      node = onAfterVisit(node, mutationContext, context);
+
+      return ts.visitEachChild(node, visitor, context);
+    };
+
+    return (sf: ts.SourceFile) => ts.visitNode(sf, visitor);
+  }
+
 }
 
-function getConfig(config: Config = {}): Config {
-  return Object.assign({}, DEFAULT_CONFIG, config);
+export function getOptions(options: Options = {}): Options {
+  const opts = Object.assign({}, defaultOptions, options);
+  opts.compilerOptions = Object.assign({}, defaultOptions.compilerOptions, options.compilerOptions || {});
+  return opts;
 }
 
-function getFiles(files: string | string[]): string[] {
-  if (typeof files === 'string') {
-    files = [files];
+function getRootNames(rootNames: string | string[]): string[] {
+  if (Array.isArray(rootNames)) {
+    return rootNames;
   }
 
-  if (!Array.isArray(files)) {
-    bus.emit('error', new TypeError('Files passed to transform must be of type string[] or string.'));
+  return [rootNames];
+}
+
+function getTempPath(basePath: string, tempFolderName: string): string {
+  return path.join(basePath, tempFolderName);
+}
+
+function toTempFilePath(file: string, basePath: string, tempFolderName: string): string {
+  const pathFromBase = path.dirname(file.replace(basePath, ''));
+  const tempPath = getTempPath(basePath, tempFolderName);
+  const fileName = path.basename(file);
+
+  return path.join(tempPath, pathFromBase, fileName);
+}
+
+function check(diagnostics: ts.Diagnostic[]): boolean {
+  if (diagnostics && diagnostics.length > 0) {
+    notify(bus.events.DIAGNOSTICS, { diagnostics });
+    console.error(ts.formatDiagnostics(diagnostics, {
+      getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
+      getNewLine: () => ts.sys.newLine,
+      getCanonicalFileName: (f: string) => f
+    }));
+    return false;
   }
 
-  return files as string[];
+  return true;
 }
 
-export default transform;
+function notify(event: string | symbol, ...args: any[]): boolean {
+  return bus.emitter.emit(event, args);
+}
diff --git a/src/next/util.ts b/src/util.ts
similarity index 100%
rename from src/next/util.ts
rename to src/util.ts
diff --git a/src/yarn.lock b/src/yarn.lock
deleted file mode 100644
index 0656dce..0000000
--- a/src/yarn.lock
+++ /dev/null
@@ -1,87 +0,0 @@
-# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
-# yarn lockfile v1
-
-
-ansi-regex@^2.0.0:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-2.1.1.tgz#c3b33ab5ee360d86e0e628f0468ae7ef27d654df"
-
-ansi-styles@^2.2.1:
-  version "2.2.1"
-  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-2.2.1.tgz#b432dd3358b634cf75e1e4664368240533c1ddbe"
-
-chalk@^1.0.0, chalk@^1.1.1:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/chalk/-/chalk-1.1.3.tgz#a8115c55e4a702fe4d150abd3872822a7e09fc98"
-  dependencies:
-    ansi-styles "^2.2.1"
-    escape-string-regexp "^1.0.2"
-    has-ansi "^2.0.0"
-    strip-ansi "^3.0.0"
-    supports-color "^2.0.0"
-
-cli-cursor@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-2.1.0.tgz#b35dac376479facc3e94747d41d0d0f5238ffcb5"
-  dependencies:
-    restore-cursor "^2.0.0"
-
-cli-spinners@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/cli-spinners/-/cli-spinners-1.0.0.tgz#ef987ed3d48391ac3dab9180b406a742180d6e6a"
-
-escape-string-regexp@^1.0.2:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4"
-
-has-ansi@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/has-ansi/-/has-ansi-2.0.0.tgz#34f5049ce1ecdf2b0649af3ef24e45ed35416d91"
-  dependencies:
-    ansi-regex "^2.0.0"
-
-log-symbols@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/log-symbols/-/log-symbols-1.0.2.tgz#376ff7b58ea3086a0f09facc74617eca501e1a18"
-  dependencies:
-    chalk "^1.0.0"
-
-mimic-fn@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-1.1.0.tgz#e667783d92e89dbd342818b5230b9d62a672ad18"
-
-onetime@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/onetime/-/onetime-2.0.0.tgz#52aa8110e52fc5126ffc667bd8ec21c2ed209ce6"
-  dependencies:
-    mimic-fn "^1.0.0"
-
-ora@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/ora/-/ora-1.1.0.tgz#69aaa4a209630e43b142c5f7ff41820da87e2faf"
-  dependencies:
-    chalk "^1.1.1"
-    cli-cursor "^2.1.0"
-    cli-spinners "^1.0.0"
-    log-symbols "^1.0.2"
-
-restore-cursor@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-2.0.0.tgz#9f7ee287f82fd326d4fd162923d62129eee0dfaf"
-  dependencies:
-    onetime "^2.0.0"
-    signal-exit "^3.0.2"
-
-signal-exit@^3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.2.tgz#b5fdc08f1287ea1178628e415e25132b73646c6d"
-
-strip-ansi@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-3.0.1.tgz#6a385fb8853d952d5ff05d0e8aaf94278dc63dcf"
-  dependencies:
-    ansi-regex "^2.0.0"
-
-supports-color@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-2.0.0.tgz#535d045ce6b6363fa40117084629995e9df324c7"

From bde9a8e704907a89d82adf6085223ba7aeeda0b5 Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Thu, 16 Mar 2017 23:42:37 +0100
Subject: [PATCH 19/26] Identified missing type generators.

---
 src/context.ts                          | 2 +-
 src/generator.ts                        | 4 ++--
 src/playground/snippets/.tsr/source3.ts | 6 +++---
 src/playground/snippets/source3.js      | 6 +++---
 src/util.ts                             | 4 ++++
 5 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/src/context.ts b/src/context.ts
index 5e96159..4419bb8 100644
--- a/src/context.ts
+++ b/src/context.ts
@@ -67,7 +67,7 @@ export class MutationContext {
     return '';
   }
 
-  // TODO: primitive types fail sometimes
+  // TODO: handle LastTypeNode (and FirstTypeNode)
   public getImplicitTypeNode(node: ts.Node): ts.TypeNode {
     let type = this.checker.getTypeAtLocation(node);
     let typeString = this.checker.typeToString(type);
diff --git a/src/generator.ts b/src/generator.ts
index dc7f10c..4e89b89 100644
--- a/src/generator.ts
+++ b/src/generator.ts
@@ -22,7 +22,7 @@ export function typeAssertion(id: string | ts.Expression, args: ts.Expression |
   return propertyAccessCall(id, 'assert', args, types);
 }
 
-// TODO: Add ParenthesizedType (among others)
+// TODO: Add ParenthesizedType, LiteralType,...
 export function typeDefinition(type: string | ts.TypeNode): ts.CallExpression {
   if (!type) {
     return null;
@@ -82,7 +82,7 @@ export function typeDefinition(type: string | ts.TypeNode): ts.CallExpression {
       }
     default:
       {
-        return propertyAccessCall(LIB, 'any');
+        return propertyAccessCall(LIB, 'unknown');
       }
   }
 }
diff --git a/src/playground/snippets/.tsr/source3.ts b/src/playground/snippets/.tsr/source3.ts
index decbfde..9b3372c 100644
--- a/src/playground/snippets/.tsr/source3.ts
+++ b/src/playground/snippets/.tsr/source3.ts
@@ -1,4 +1,4 @@
-export const bla = t.any().assert('bla');
+export const bla = t.unknown().assert('bla');
 console.log(bla);
 type TestType = {
     name: string;
@@ -24,12 +24,12 @@ hasNoType = 5;
 var _hiType = t.string(), hi: string;
 hi = _hiType.assert(console);
 const y = t.array(t.string()).assert(['hallo', 'du']);
-const z = t.any().assert('hhh');
+const z = t.unknown().assert('hhh');
 const h = t.array(t.number()).assert([1, 2]);
 x = _xType.assert(5);
 x = _xType.assert('hi');
 hasNoType = 'str';
 export const bla = t.array(t.number()).assert([10]);
-const blub = t.any().assert('str');
+const blub = t.unknown().assert('str');
 let _wefkhType = t.number(), wefkh = _wefkhType.assert(111);
 x = _xType.assert(5);
diff --git a/src/playground/snippets/source3.js b/src/playground/snippets/source3.js
index 84bd5ba..9e56a45 100644
--- a/src/playground/snippets/source3.js
+++ b/src/playground/snippets/source3.js
@@ -1,4 +1,4 @@
-export const bla = t.any().assert('bla');
+export const bla = t.unknown().assert('bla');
 console.log(bla);
 const a = t.string().assert('hallo');
 let _bType = t.array(t.number()), b;
@@ -21,12 +21,12 @@ hasNoType = 5;
 var _hiType = t.string(), hi;
 hi = _hiType.assert(console);
 const y = t.array(t.string()).assert(['hallo', 'du']);
-const z = t.any().assert('hhh');
+const z = t.unknown().assert('hhh');
 const h = t.array(t.number()).assert([1, 2]);
 x = _xType.assert(5);
 x = _xType.assert('hi');
 hasNoType = 'str';
 export const bla = t.array(t.number()).assert([10]);
-const blub = t.any().assert('str');
+const blub = t.unknown().assert('str');
 let _wefkhType = t.number(), wefkh = _wefkhType.assert(111);
 x = _xType.assert(5);
diff --git a/src/util.ts b/src/util.ts
index 1c6c17a..efc1c68 100644
--- a/src/util.ts
+++ b/src/util.ts
@@ -20,6 +20,10 @@ export function getScope(node: ts.Node): ts.Node {
   return getScope(node.parent);
 }
 
+export function isAnyOrLiteralKind(kind: ts.SyntaxKind): boolean {
+  return kind === ts.SyntaxKind.AnyKeyword || kind === ts.SyntaxKind.LiteralType;
+}
+
 // TODO: test
 export function identifierExistsUp(node: ts.Node, id: string | ts.Identifier) {
   if (typeof id !== 'string') id = id.text;

From 3c8282e8e4edcc3770fc3861ee01fe13d1512ca7 Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Thu, 23 Mar 2017 16:31:08 +0100
Subject: [PATCH 20/26] Implemented more types.

---
 src/generator.ts | 81 ++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 78 insertions(+), 3 deletions(-)

diff --git a/src/generator.ts b/src/generator.ts
index 4e89b89..3d13555 100644
--- a/src/generator.ts
+++ b/src/generator.ts
@@ -14,7 +14,7 @@ export function typeDeclaration(name: string | ts.Identifier, type: string | ts.
   return ts.createVariableDeclaration(name, undefined, typeDefinition(type));
 }
 
-export function typeDefinitionAndAssertion(type: string | ts.TypeNode, args: ts.Expression | ts.Expression[] = [], types: ts.TypeNode | ts.TypeNode[] = []): ts.CallExpression {
+export function typeDefinitionAndAssertion(type: string | ts.TypeNode, args: ts.Expression | ts.Expression[] = [], types: ts.TypeNode | ts.TypeNode[] = []): ts.CallExpression {
   return typeAssertion(typeDefinition(type), args, types);
 }
 
@@ -23,7 +23,26 @@ export function typeAssertion(id: string | ts.Expression, args: ts.Expression |
 }
 
 // TODO: Add ParenthesizedType, LiteralType,...
-export function typeDefinition(type: string | ts.TypeNode): ts.CallExpression {
+// Array, Object and Function Destructuring
+// Spread operator
+// Default values
+// Remove types in .tsr
+//
+// VoidKeyword (only undefined or null for variables) OK
+// NeverKeyword
+// EnumKeyword
+//
+// ParenthesizedType OK
+// LiteralType
+// UnionType OK
+//
+// TypePredicate
+// ThisType OK
+// TypeOperator
+// IndexedAccessType
+// MappedType
+// TypeAliasDeclaration
+export function typeDefinition(type: string | ts.TypeNode): ts.CallExpression {
   if (!type) {
     return null;
   }
@@ -39,13 +58,68 @@ export function typeDefinition(type: string | ts.TypeNode): ts.CallExpression {
     case ts.SyntaxKind.NumberKeyword:
     case ts.SyntaxKind.StringKeyword:
     case ts.SyntaxKind.AnyKeyword:
+    case ts.SyntaxKind.NullKeyword:
       {
         return propertyAccessCall(LIB, type.getText());
       }
+    case ts.SyntaxKind.SymbolKeyword:
+      {
+        return propertyAccessCall(LIB, 'ref', ts.createIdentifier('Symbol'));
+      }
+    case ts.SyntaxKind.UndefinedKeyword:
+      {
+        return propertyAccessCall(LIB, 'void');
+      }
+    case ts.SyntaxKind.VoidKeyword:
+      {
+        return propertyAccessCall(LIB, 'union', [
+          propertyAccessCall(LIB, 'void'),
+          propertyAccessCall(LIB, 'null')
+        ]);
+      }
+    case ts.SyntaxKind.ParenthesizedType:
+      {
+        return typeDefinition((type as ts.ParenthesizedTypeNode).type);
+      }
+    case ts.SyntaxKind.LiteralType:
+      {
+        const ltn = type as ts.LiteralTypeNode;
+
+        switch (ltn.literal.kind)  {
+          case ts.SyntaxKind.TrueKeyword:
+            return propertyAccessCall(LIB, 'boolean', ts.createTrue());
+          case ts.SyntaxKind.FalseKeyword:
+            return propertyAccessCall(LIB, 'boolean', ts.createFalse());
+          case ts.SyntaxKind.StringLiteral:
+            const str = ltn.literal.getText();
+            return propertyAccessCall(LIB, 'string', ts.createLiteral(str.substring(1, str.length - 1)));
+          case ts.SyntaxKind.NumericLiteral:
+            return propertyAccessCall(LIB, 'number', ts.createNumericLiteral(ltn.literal.getText()));
+          default:
+            // TODO: Throw exception here?
+            {
+              const str = ltn.literal.getText();
+              return propertyAccessCall(LIB, 'ref', ts.createIdentifier(str.substring(1, str.length - 1)));
+            }
+        }
+      }
+    case ts.SyntaxKind.ThisType:
+      {
+        return propertyAccessCall(LIB, 'this', ts.createThis());
+      }
+    case ts.SyntaxKind.UnionType:
+      {
+        let args: ts.CallExpression[] = (type as ts.UnionTypeNode).types.map(typeNode => {
+          return typeDefinition(typeNode);
+        });
+
+        return propertyAccessCall(LIB, 'union', args);
+      }
     case ts.SyntaxKind.ArrayType:
       {
         const typeNode = (type as ts.ArrayTypeNode).elementType as ts.TypeNode;
         const callExpression = propertyAccessCall(LIB, 'array', typeDefinition(typeNode));
+
         return callExpression;
       }
     case ts.SyntaxKind.TypeReference:
@@ -56,7 +130,7 @@ export function typeDefinition(type: string | ts.TypeNode): ts.CallExpression {
         let callExpression: ts.CallExpression;
 
         if (typeRef.typeArguments) {
-          for (const arg of typeRef.typeArguments) {
+          for (let arg of typeRef.typeArguments) {
             args.push(typeDefinition(arg));
           }
         }
@@ -82,6 +156,7 @@ export function typeDefinition(type: string | ts.TypeNode): ts.CallExpression {
       }
     default:
       {
+        // TODO: Throw exception, type cannot be classified.
         return propertyAccessCall(LIB, 'unknown');
       }
   }

From 7125b1425f07ea6531a03e9f4132fc1289fc45fd Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Thu, 23 Mar 2017 16:31:24 +0100
Subject: [PATCH 21/26] Added .tsr to gitignore.

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index cdeda3e..b25819b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,3 +7,4 @@ logs
 pids
 *.pid
 *.seed
+.tsr

From 6582d372142c5d0fc5bcd70b60a5076a881e4569 Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Thu, 23 Mar 2017 16:32:06 +0100
Subject: [PATCH 22/26] Minor improvements.

---
 src/context.ts   |  43 +++-------
 src/transform.ts | 207 +++++++++++++++--------------------------------
 src/util.ts      |   2 +
 3 files changed, 78 insertions(+), 174 deletions(-)

diff --git a/src/context.ts b/src/context.ts
index 4419bb8..aaee5e1 100644
--- a/src/context.ts
+++ b/src/context.ts
@@ -1,8 +1,6 @@
 import * as ts from 'typescript';
 import * as util from './util';
-import { Options } from './options';
-
-export type Scope = ts.SourceFile | ts.Block | ts.ModuleBlock | ts.CaseBlock;
+import { Options, defaultOptions } from './options';
 
 export class MutationContext {
 
@@ -11,18 +9,17 @@ export class MutationContext {
   private _program: ts.Program;
   private _checker: ts.TypeChecker;
   private _host: ts.CompilerHost;
-  private _scope: Scope;
   private _visited: ts.Node[];
   private _transformationContext: ts.TransformationContext;
 
-  constructor(options: Options, sourceFile: ts.SourceFile, program: ts.Program, host: ts.CompilerHost) {
+  constructor(options: Options, sourceFile: ts.SourceFile, program: ts.Program, host: ts.CompilerHost, context: ts.TransformationContext) {
     this._options = options;
     this._sourceFile = sourceFile;
     this._program = program;
     this._checker = program.getTypeChecker();
     this._host = host;
-    this._scope = sourceFile;
     this._visited = [];
+    this._transformationContext = context;
   }
 
   public wasVisited(node: ts.Node): boolean {
@@ -68,14 +65,18 @@ export class MutationContext {
   }
 
   // TODO: handle LastTypeNode (and FirstTypeNode)
-  public getImplicitTypeNode(node: ts.Node): ts.TypeNode {
-    let type = this.checker.getTypeAtLocation(node);
-    let typeString = this.checker.typeToString(type);
+  public getImplicitTypeNode(node: string | ts.Node): ts.TypeNode {
+    const typeString = typeof node === 'string' ? node : this.getImplicitTypeText(node);
     let source = `let temp: ${typeString};`;
-    let sf = ts.createSourceFile('temp', source, this.compilerOptions.target || ts.ScriptTarget.ES2015, true, ts.ScriptKind.TS);
+    let sf = ts.createSourceFile('temp', source, this.compilerOptions.target || defaultOptions.compilerOptions.target, true, ts.ScriptKind.TS);
     return (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type;
   }
 
+  public getImplicitTypeText(node: ts.Node): string {
+    const type = this.checker.getTypeAtLocation(node);
+    return this.checker.typeToString(type);
+  }
+
   public getType(node: ts.Node): ts.Type {
     return this.checker.getTypeAtLocation(node);
   }
@@ -106,28 +107,6 @@ export class MutationContext {
     return this._visited;
   }
 
-  get scope() {
-    return this._scope;
-  }
-
-  set scope(node: ts.Node) {
-    switch (node.kind) {
-      case ts.SyntaxKind.SourceFile:
-        this._sourceFile = node as ts.SourceFile;
-      case ts.SyntaxKind.Block:
-      case ts.SyntaxKind.ModuleBlock:
-      case ts.SyntaxKind.CaseBlock:
-        this._scope = node as Scope;
-        break;
-      default:
-      throw new Error(`Scope must be SourceFile, Block, ModuleBlock or CaseBlock, got ${ts.SyntaxKind[node.kind]}.`);
-    }
-  }
-
-  public setScope(node: ts.Node): void {
-    this.scope = node;
-  }
-
   get sourceFile() {
     return this._sourceFile;
   }
diff --git a/src/transform.ts b/src/transform.ts
index bb212a3..aa66ba7 100644
--- a/src/transform.ts
+++ b/src/transform.ts
@@ -7,7 +7,7 @@ import { MutationContext } from './context';
 import { mutators } from './mutators';
 import { Options, defaultOptions } from './options';
 
-const DEBUG = false;
+const DEBUG = true;
 
 export function transform(entryFile: string, options?: Options) {
   options = getOptions(options);
@@ -15,9 +15,7 @@ export function transform(entryFile: string, options?: Options) {
   let host: ts.CompilerHost;
   let program: ts.Program;
 
-  startTransformation();
-
-  function startTransformation(): void {
+  (function autoStartTransformation(): void {
     notify(bus.events.START, { entryFile, options });
 
     const basePath = path.dirname(entryFile);
@@ -79,7 +77,7 @@ export function transform(entryFile: string, options?: Options) {
 
     result.dispose();
 
-    emit();
+    emitTransformed();
 
     if (!options.keepTempFiles) {
       const tempPath = getTempPath(basePath, options.tempFolderName);
@@ -89,9 +87,9 @@ export function transform(entryFile: string, options?: Options) {
     }
 
     notify(bus.events.END, { entryFile, options });
-  }
+  })();
 
-  function emit() {
+  function emitTransformed() {
     const tempEntryFile = toTempFilePath(entryFile, path.dirname(entryFile), options.tempFolderName);
     notify(bus.events.EMIT_START, { entryFile, tempEntryFile, options });
 
@@ -127,13 +125,6 @@ export function transform(entryFile: string, options?: Options) {
   }
 
   function onBeforeVisit(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): ts.Node {
-    if (util.isKind(node, ts.SyntaxKind.SourceFile)) {
-      mc.setSourceFile(node);
-    }
-
-    mc.setTransformationContext(tc);
-    mc.setScope(util.getScope(node));
-
     return node;
   }
 
@@ -142,120 +133,22 @@ export function transform(entryFile: string, options?: Options) {
     return node;
   }
 
-  // function firstPassVisitor(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): void {
-  //   if (!node) return;
-  //   let checker = program.getTypeChecker();
-  //   ts.forEachChild(node, n => {
-  //
-  //
-  //     // let type = checker.getTypeAtLocation(n);
-  //     // // console.log('TYPE', type);
-  //     // let typeString = checker.typeToString(type);
-  //     // console.log('TYPESTRING', typeString);
-  //     // let source = `let temp: ${typeString};`;
-  //     // console.log('SRC', source);
-  //     // console.log('\n\n\n');
-  //     // let sf = ts.createSourceFile('temp', source, ts.ScriptTarget.ES2015);
-  //     // let typeNode = (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type;
-  //
-  //     switch (n.kind) {
-  //       case ts.SyntaxKind.BinaryExpression:
-  //         // console.log((n as ts.BinaryExpression).getText());
-  //         // let s = program.getTypeChecker().getSymbolAtLocation(n);
-  //         // let t = program.getTypeChecker().getContextualType(n as ts.BinaryExpression);
-  //         // console.log(s);
-  //         // console.log(t);
-  //         // console.log('\n\n');
-  //         break;
-  //       case ts.SyntaxKind.Identifier:
-  //         console.log((n as ts.Identifier).text);
-  //         console.log('-----------------------');
-  //
-  //
-  //
-  //         // let t = checker.getTypeAtLocation(n);
-  //         // // console.log(checker.getPropertiesOfType(t));
-  //         // // t = checker.getWidenedType(t);
-  //         // //
-  //         // console.log(ts.TypeFlags[t.flags]);
-  //
-  //         let type = checker.getTypeAtLocation(n);
-  //
-  //         let typeString = checker.typeToString(type);
-  //         console.log(typeString);
-  //         let source = `let temp: ${typeString};`;
-  //
-  //         let sf = ts.createSourceFile('temp', source, ts.ScriptTarget.ES2015);
-  //         let typeNode = (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type;
-  //
-  //         //
-  //         // let asm = type.aliasSymbol;
-  //         //
-  //         // if (asm) {
-  //         //   if (asm.declarations && asm.declarations[0]) {
-  //         //     console.log(asm.declarations.length);
-  //         //     let asmi = asm.declarations[0] as ts.VariableDeclaration;
-  //         //     if (asmi.type) {
-  //         //       console.log('has type');
-  //         //       console.log(ts.SyntaxKind[asmi.type.kind]);
-  //         //     }
-  //         //   }
-  //         // }
-  //         //
-  //         console.log(ts.TypeFlags[type.flags]);
-  //         console.log('\n\n');
-  //
-  //         // console.log('KIND:', (n as ts.Identifier).text);
-  //         // console.log((n as ts.Identifier).originalKeywordKind);
-  //         // console.log('');
-  //
-  //         // if (mc.names.indexOf((n as ts.Identifier).text) === -1) {
-  //         //   // mc.names.push((n as ts.Identifier).text);
-  //         //   // console.log('KIND:', (n as ts.Identifier).text);
-  //         //   // console.log((n as ts.Identifier).originalKeywordKind);
-  //         //   // console.log('');
-  //         // }
-  //         break;
-  //       case ts.SyntaxKind.VariableDeclaration:
-  //         // const dec = n as ts.VariableDeclaration;
-  //         // if (dec.name.kind === ts.SyntaxKind.Identifier) {
-  //         //   mc.declarations.set((dec.name as ts.Identifier).text, dec.type);
-  //         // }
-  //         break;
-  //     }
-  //
-  //     firstPassVisitor(n, mc, tc);
-  //   });
-  // }
-
   function transformer(context: ts.TransformationContext): ts.Transformer<ts.SourceFile> {
     let mutationContext: MutationContext;
 
     const visitor: ts.Visitor = (node: ts.Node): ts.Node => {
       if (node.kind === ts.SyntaxKind.SourceFile) {
-        mutationContext = new MutationContext(options, node as ts.SourceFile, program, host);
-        // firstPassVisitor(node as ts.SourceFile, mutationContext, context);
+        mutationContext = new MutationContext(options, node as ts.SourceFile, program, host, context);
       }
 
-      // if (node.kind === ts.SyntaxKind.SourceFile) {
-      //   console.log('---------------');
-      //   console.log('SourceFile');
-      //   console.log((node as ts.SourceFile).fileName);
-      //   console.log('---------------\n\n');
-      // } else {
-      //   console.log(ts.SyntaxKind[node.kind]);
-      // }
-
       const parent = node.parent;
       node = onBeforeVisit(node, mutationContext, context);
 
-      if (DEBUG) {
-        const scope = mutationContext.scope ? ts.SyntaxKind[mutationContext.scope.kind] : 'undefined';
-        console.log(`Visited: ${mutationContext.wasVisited(node) ? 'Yes' : 'No'}`);
-        console.log(`Scope: ${scope}`);
-        console.log(`Kind:  ${ts.SyntaxKind[node.kind]} (${node.kind})`);
-        console.log(`File:  ${mutationContext.sourceFile.fileName}`);
-      }
+      debugText('~~~~~~~~~~~~~~~~~~~~~');
+      debugText('Before Mutation:');
+      debugText('~~~~~~~~~~~~~~~~~~~~~');
+      debugNodeAttributes(node, mutationContext);
+      debugNodeText(node, mutationContext);
 
       for (let mutator of mutators) {
         node = mutator.mutateNode(node, mutationContext);
@@ -264,27 +157,16 @@ export function transform(entryFile: string, options?: Options) {
       node.parent = parent;
       util.setParent(node);
 
-      if (DEBUG) {
-        console.log('<============================================');
-        if (node.parent) {
-          if (node.flags === ts.NodeFlags.Synthesized) {
-            console.log('Cannot get text of synthesized node.');
-          } else {
-            console.log(node.getText());
-          }
-        } else {
-          console.log('Parent not set, cannot get text.');
-        }
-        console.log('============================================>');
-      }
-
-
-      if (DEBUG) {
-        console.log('\n\n');
-      }
-
       node = onAfterVisit(node, mutationContext, context);
 
+      debugSpaces();
+      debugText('~~~~~~~~~~~~~~~~~~~~~');
+      debugText('After Mutation:');
+      debugText('~~~~~~~~~~~~~~~~~~~~~');
+      debugNodeAttributes(node, mutationContext);
+      debugNodeText(node, mutationContext);
+      debugSpaces(3);
+
       return ts.visitEachChild(node, visitor, context);
     };
 
@@ -299,7 +181,7 @@ export function getOptions(options: Options = {}): Options {
   return opts;
 }
 
-function getRootNames(rootNames: string | string[]): string[] {
+export function getRootNames(rootNames: string | string[]): string[] {
   if (Array.isArray(rootNames)) {
     return rootNames;
   }
@@ -307,11 +189,11 @@ function getRootNames(rootNames: string | string[]): string[] {
   return [rootNames];
 }
 
-function getTempPath(basePath: string, tempFolderName: string): string {
+export function getTempPath(basePath: string, tempFolderName: string): string {
   return path.join(basePath, tempFolderName);
 }
 
-function toTempFilePath(file: string, basePath: string, tempFolderName: string): string {
+export function toTempFilePath(file: string, basePath: string, tempFolderName: string): string {
   const pathFromBase = path.dirname(file.replace(basePath, ''));
   const tempPath = getTempPath(basePath, tempFolderName);
   const fileName = path.basename(file);
@@ -319,7 +201,7 @@ function toTempFilePath(file: string, basePath: string, tempFolderName: string):
   return path.join(tempPath, pathFromBase, fileName);
 }
 
-function check(diagnostics: ts.Diagnostic[]): boolean {
+export function check(diagnostics: ts.Diagnostic[]): boolean {
   if (diagnostics && diagnostics.length > 0) {
     notify(bus.events.DIAGNOSTICS, { diagnostics });
     console.error(ts.formatDiagnostics(diagnostics, {
@@ -333,6 +215,47 @@ function check(diagnostics: ts.Diagnostic[]): boolean {
   return true;
 }
 
-function notify(event: string | symbol, ...args: any[]): boolean {
+export function notify(event: string | symbol, ...args: any[]): boolean {
   return bus.emitter.emit(event, args);
 }
+
+function debugNodeAttributes(node: ts.Node, mutationContext: MutationContext): void {
+  if (!DEBUG) return;
+  const scope = util.getScope(node);
+  const scopeKind = scope ? ts.SyntaxKind[scope.kind] : 'undefined';
+  console.log(`Kind: ${ts.SyntaxKind[node.kind]} (${node.kind})`);
+  try {
+    console.log(`Implicit Type: ${mutationContext.getImplicitTypeText(node)}`);
+  } catch (e) {
+    console.log('Implicit Type:');
+  }
+  console.log(`Visited: ${mutationContext.wasVisited(node) ? 'Yes' : 'No'}`);
+  console.log(`Scope: ${scopeKind}`);
+  console.log(`Synthesized: ${node.flags === ts.NodeFlags.Synthesized ? 'Yes' : 'No'}`);
+  console.log(`File: ${mutationContext.sourceFile.fileName}`);
+}
+
+function debugNodeText(node: ts.Node, mutstionContext: MutationContext) {
+  if (!DEBUG) return;
+  console.log('<============================================');
+  if (node.parent) {
+    if (node.flags === ts.NodeFlags.Synthesized) {
+      console.log('Cannot get text of synthesized node.');
+    } else {
+      console.log(node.getText());
+    }
+  } else {
+    console.log('Parent not set, cannot get text.');
+  }
+  console.log('============================================>');
+}
+
+function debugText(text: string) {
+  if (!DEBUG) return;
+  console.log(text);
+}
+
+function debugSpaces(spaces: number = 1) {
+  if (!DEBUG) return;
+  console.log(Array(Math.abs(spaces) + 1).join('\n'));
+}
diff --git a/src/util.ts b/src/util.ts
index efc1c68..c5cf7e9 100644
--- a/src/util.ts
+++ b/src/util.ts
@@ -1,5 +1,7 @@
 import * as ts from 'typescript';
 
+export type Scope = ts.SourceFile | ts.Block | ts.ModuleBlock | ts.CaseBlock;
+
 export function setParent(node: ts.Node): void {
   if (!node) return;
   ts.forEachChild(node, n => {

From 7eac13189634e5ef3425312f0ad58655ef59b1f0 Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Thu, 23 Mar 2017 16:32:45 +0100
Subject: [PATCH 23/26] Code improvements.

---
 src/mutators/VariableDeclarationListMutator.ts | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/mutators/VariableDeclarationListMutator.ts b/src/mutators/VariableDeclarationListMutator.ts
index 07187b8..c18daab 100644
--- a/src/mutators/VariableDeclarationListMutator.ts
+++ b/src/mutators/VariableDeclarationListMutator.ts
@@ -102,11 +102,7 @@ export class VariableDeclarationListMutator extends Mutator {
 
   private transformUntypedConstDeclaration(node: ts.VariableDeclaration): ts.VariableDeclaration[] {
     const nodeName = this.context.getTypeDeclarationName(node.name.getText());
-
-    console.log(node.name.getText());
     const implicitType = this.context.getImplicitTypeNode(node.name);
-    console.log(ts.SyntaxKind[implicitType.kind]);
-    console.log('\n');
 
     if (!this.context.options.assertAny && implicitType.kind === ts.SyntaxKind.AnyKeyword) {
       return [node];

From 371c771297daa6cb326447b627e3231f101ed62b Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Thu, 23 Mar 2017 16:33:02 +0100
Subject: [PATCH 24/26] Changes to examples.

---
 src/playground/run.ts                   |  7 +++--
 src/playground/snippets/.tsr/source3.ts | 35 ---------------------
 src/playground/snippets/.tsr/source4.ts | 24 --------------
 src/playground/snippets/source3.js      | 32 -------------------
 src/playground/snippets/source4.js      | 21 -------------
 src/playground/snippets/source5.js      | 32 +++++++++++++++++++
 src/playground/snippets/source5.ts      | 42 +++++++++++++++++++++++++
 src/playground/snippets/source6.js      |  3 ++
 src/playground/snippets/source6.ts      |  3 ++
 9 files changed, 84 insertions(+), 115 deletions(-)
 delete mode 100644 src/playground/snippets/.tsr/source3.ts
 delete mode 100644 src/playground/snippets/.tsr/source4.ts
 delete mode 100644 src/playground/snippets/source3.js
 delete mode 100644 src/playground/snippets/source4.js
 create mode 100644 src/playground/snippets/source5.js
 create mode 100644 src/playground/snippets/source5.ts
 create mode 100644 src/playground/snippets/source6.js
 create mode 100644 src/playground/snippets/source6.ts

diff --git a/src/playground/run.ts b/src/playground/run.ts
index 189bd12..3166a38 100644
--- a/src/playground/run.ts
+++ b/src/playground/run.ts
@@ -1,6 +1,7 @@
 import * as path from 'path';
 import * as tsr from '../';
 
-tsr.transform(path.join(__dirname, './snippets/source4.ts'), {
-  compilerOptions: {}
-});
+const args = process.argv.slice(2);
+const file = path.join(__dirname, `./snippets/${args[0]}.ts`);
+
+tsr.transform(file, { keepTempFiles: true });
diff --git a/src/playground/snippets/.tsr/source3.ts b/src/playground/snippets/.tsr/source3.ts
deleted file mode 100644
index 9b3372c..0000000
--- a/src/playground/snippets/.tsr/source3.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-export const bla = t.unknown().assert('bla');
-console.log(bla);
-type TestType = {
-    name: string;
-};
-const a: string = t.string().assert('hallo');
-let _bType = t.array(t.number()), b: number[];
-b = _bType.assert([10]);
-function testFunction(t: TestType): string {
-    return 'Hello ' + t.name;
-}
-console.log(testFunction({ name: 'Alice' }));
-let hasAnyType: any;
-hasAnyType = 55;
-const constAny: any = 10;
-function getX() {
-    return [1, 2, 3];
-}
-let _aaaType = t.number(), aaa = _aaaType.assert(10);
-const bbb = t.array(t.number()).assert(getX());
-let _xType = t.array(t.number()), x = _xType.assert([5, 10]);
-let hasNoType;
-hasNoType = 5;
-var _hiType = t.string(), hi: string;
-hi = _hiType.assert(console);
-const y = t.array(t.string()).assert(['hallo', 'du']);
-const z = t.unknown().assert('hhh');
-const h = t.array(t.number()).assert([1, 2]);
-x = _xType.assert(5);
-x = _xType.assert('hi');
-hasNoType = 'str';
-export const bla = t.array(t.number()).assert([10]);
-const blub = t.unknown().assert('str');
-let _wefkhType = t.number(), wefkh = _wefkhType.assert(111);
-x = _xType.assert(5);
diff --git a/src/playground/snippets/.tsr/source4.ts b/src/playground/snippets/.tsr/source4.ts
deleted file mode 100644
index e58abd9..0000000
--- a/src/playground/snippets/.tsr/source4.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { bla } from './source3';
-console.log(bla);
-type TestType = {
-    name: string;
-};
-const a: string = t.string().assert('hallo');
-let _bType = t.array(t.number()), b: number[];
-b = _bType.assert([10]);
-function testFunction(t: TestType): string {
-    return 'Hello ' + t.name;
-}
-console.log(testFunction({ name: 'Alice' }));
-let hasAnyType: any;
-hasAnyType = 55;
-const constAny: any = 10;
-let _xType = t.array(t.number()), x = _xType.assert([5, 10]);
-let hasNoType;
-hasNoType = 5;
-var _hiType = t.string(), hi: string;
-hi = _hiType.assert(console);
-const y = t.array(t.string()).assert(['hallo', 'du']);
-x = _xType.assert(5);
-x = _xType.assert('hi');
-hasNoType = 'str';
diff --git a/src/playground/snippets/source3.js b/src/playground/snippets/source3.js
deleted file mode 100644
index 9e56a45..0000000
--- a/src/playground/snippets/source3.js
+++ /dev/null
@@ -1,32 +0,0 @@
-export const bla = t.unknown().assert('bla');
-console.log(bla);
-const a = t.string().assert('hallo');
-let _bType = t.array(t.number()), b;
-b = _bType.assert([10]);
-function testFunction(t) {
-    return 'Hello ' + t.name;
-}
-console.log(testFunction({ name: 'Alice' }));
-let hasAnyType;
-hasAnyType = 55;
-const constAny = 10;
-function getX() {
-    return [1, 2, 3];
-}
-let _aaaType = t.number(), aaa = _aaaType.assert(10);
-const bbb = t.array(t.number()).assert(getX());
-let _xType = t.array(t.number()), x = _xType.assert([5, 10]);
-let hasNoType;
-hasNoType = 5;
-var _hiType = t.string(), hi;
-hi = _hiType.assert(console);
-const y = t.array(t.string()).assert(['hallo', 'du']);
-const z = t.unknown().assert('hhh');
-const h = t.array(t.number()).assert([1, 2]);
-x = _xType.assert(5);
-x = _xType.assert('hi');
-hasNoType = 'str';
-export const bla = t.array(t.number()).assert([10]);
-const blub = t.unknown().assert('str');
-let _wefkhType = t.number(), wefkh = _wefkhType.assert(111);
-x = _xType.assert(5);
diff --git a/src/playground/snippets/source4.js b/src/playground/snippets/source4.js
deleted file mode 100644
index 838722f..0000000
--- a/src/playground/snippets/source4.js
+++ /dev/null
@@ -1,21 +0,0 @@
-import { bla } from './source3';
-console.log(bla);
-const a = t.string().assert('hallo');
-let _bType = t.array(t.number()), b;
-b = _bType.assert([10]);
-function testFunction(t) {
-    return 'Hello ' + t.name;
-}
-console.log(testFunction({ name: 'Alice' }));
-let hasAnyType;
-hasAnyType = 55;
-const constAny = 10;
-let _xType = t.array(t.number()), x = _xType.assert([5, 10]);
-let hasNoType;
-hasNoType = 5;
-var _hiType = t.string(), hi;
-hi = _hiType.assert(console);
-const y = t.array(t.string()).assert(['hallo', 'du']);
-x = _xType.assert(5);
-x = _xType.assert('hi');
-hasNoType = 'str';
diff --git a/src/playground/snippets/source5.js b/src/playground/snippets/source5.js
new file mode 100644
index 0000000..c2e604c
--- /dev/null
+++ b/src/playground/snippets/source5.js
@@ -0,0 +1,32 @@
+import { test } from './source6';
+// Variable with implicit complex type
+let _aType = t.array(t.number()), a = _aType.assert(test());
+// Constant with implicit complex type
+const b = t.array(t.number()).assert(test());
+// Variable reassignment
+a = _aType.assert(19);
+// Constant with explicit any type
+const c = 10;
+// Variable with explicit any type
+let d = 'foo';
+d = 'bar';
+// Variable with implicit any type
+let f;
+f = 'hi';
+// Variable with explicit complex type
+let _gType = t.array(t.ref(Symbol)), g;
+g = _gType.assert([Symbol(1), Symbol(2)]);
+let _hType = t.union(t.void(), t.null()), h;
+let _iType = t.union(t.number(), t.array(t.array(t.boolean())), t.ref(Symbol)), i;
+let _jType = t.void(), j;
+let _kType = t.null(), k;
+let _lType = t.ref(Symbol), l;
+let _mType = t.this(this), m;
+// Variable with implicit complex type
+let _eType = t.array(t.union(t.string(), t.number())), e = _eType.assert(['one', 10, 'three']);
+e = _eType.assert('hello');
+let _nType = t.number(10), n;
+let _oType = t.boolean(true), o;
+let _pType = t.string("str"), p;
+let _qType = t.boolean(false), q;
+let _nType = t.ref(o), n;
diff --git a/src/playground/snippets/source5.ts b/src/playground/snippets/source5.ts
new file mode 100644
index 0000000..a43b231
--- /dev/null
+++ b/src/playground/snippets/source5.ts
@@ -0,0 +1,42 @@
+import { test } from './source6';
+
+// Variable with implicit complex type
+let a = test();
+
+// Constant with implicit complex type
+const b = test();
+
+// Variable reassignment
+a = 19;
+
+// Constant with explicit any type
+const c: any = 10;
+
+// Variable with explicit any type
+let d: any = 'foo';
+d = 'bar';
+
+// Variable with implicit any type
+let f;
+f = 'hi';
+
+// Variable with explicit complex type
+let g: Symbol[];
+g = [Symbol(1), Symbol(2)];
+
+let h: void;
+let i: number | boolean[][] | Symbol;
+let j: undefined;
+let k: null;
+let l: symbol;
+let m: this;
+
+// Variable with implicit complex type
+let e = ['one', 10, 'three'];
+e = 'hello';
+
+let n: 10;
+let o: true;
+let p: 'str';
+let q: false;
+let n: o;
diff --git a/src/playground/snippets/source6.js b/src/playground/snippets/source6.js
new file mode 100644
index 0000000..c3ed19e
--- /dev/null
+++ b/src/playground/snippets/source6.js
@@ -0,0 +1,3 @@
+export function test() {
+    return [5, 10, 2];
+}
diff --git a/src/playground/snippets/source6.ts b/src/playground/snippets/source6.ts
new file mode 100644
index 0000000..fad06b7
--- /dev/null
+++ b/src/playground/snippets/source6.ts
@@ -0,0 +1,3 @@
+export function test() {
+  return [5, 10, 2];
+}

From 28044e1039c5ec635cbc67e1befb47e48083d8ea Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Thu, 23 Mar 2017 16:33:24 +0100
Subject: [PATCH 25/26] Moved first pass visitor to archive.

---
 src/_archived/firstPassVisitor.ts | 85 +++++++++++++++++++++++++++++++
 1 file changed, 85 insertions(+)
 create mode 100644 src/_archived/firstPassVisitor.ts

diff --git a/src/_archived/firstPassVisitor.ts b/src/_archived/firstPassVisitor.ts
new file mode 100644
index 0000000..cef9617
--- /dev/null
+++ b/src/_archived/firstPassVisitor.ts
@@ -0,0 +1,85 @@
+// function firstPassVisitor(node: ts.Node, mc: MutationContext, tc: ts.TransformationContext): void {
+//   if (!node) return;
+//   let checker = program.getTypeChecker();
+//   ts.forEachChild(node, n => {
+//
+//
+//     // let type = checker.getTypeAtLocation(n);
+//     // // console.log('TYPE', type);
+//     // let typeString = checker.typeToString(type);
+//     // console.log('TYPESTRING', typeString);
+//     // let source = `let temp: ${typeString};`;
+//     // console.log('SRC', source);
+//     // console.log('\n\n\n');
+//     // let sf = ts.createSourceFile('temp', source, ts.ScriptTarget.ES2015);
+//     // let typeNode = (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type;
+//
+//     switch (n.kind) {
+//       case ts.SyntaxKind.BinaryExpression:
+//         // console.log((n as ts.BinaryExpression).getText());
+//         // let s = program.getTypeChecker().getSymbolAtLocation(n);
+//         // let t = program.getTypeChecker().getContextualType(n as ts.BinaryExpression);
+//         // console.log(s);
+//         // console.log(t);
+//         // console.log('\n\n');
+//         break;
+//       case ts.SyntaxKind.Identifier:
+//         console.log((n as ts.Identifier).text);
+//         console.log('-----------------------');
+//
+//
+//
+//         // let t = checker.getTypeAtLocation(n);
+//         // // console.log(checker.getPropertiesOfType(t));
+//         // // t = checker.getWidenedType(t);
+//         // //
+//         // console.log(ts.TypeFlags[t.flags]);
+//
+//         let type = checker.getTypeAtLocation(n);
+//
+//         let typeString = checker.typeToString(type);
+//         console.log(typeString);
+//         let source = `let temp: ${typeString};`;
+//
+//         let sf = ts.createSourceFile('temp', source, ts.ScriptTarget.ES2015);
+//         let typeNode = (sf.statements[0] as ts.VariableStatement).declarationList.declarations[0].type;
+//
+//         //
+//         // let asm = type.aliasSymbol;
+//         //
+//         // if (asm) {
+//         //   if (asm.declarations && asm.declarations[0]) {
+//         //     console.log(asm.declarations.length);
+//         //     let asmi = asm.declarations[0] as ts.VariableDeclaration;
+//         //     if (asmi.type) {
+//         //       console.log('has type');
+//         //       console.log(ts.SyntaxKind[asmi.type.kind]);
+//         //     }
+//         //   }
+//         // }
+//         //
+//         console.log(ts.TypeFlags[type.flags]);
+//         console.log('\n\n');
+//
+//         // console.log('KIND:', (n as ts.Identifier).text);
+//         // console.log((n as ts.Identifier).originalKeywordKind);
+//         // console.log('');
+//
+//         // if (mc.names.indexOf((n as ts.Identifier).text) === -1) {
+//         //   // mc.names.push((n as ts.Identifier).text);
+//         //   // console.log('KIND:', (n as ts.Identifier).text);
+//         //   // console.log((n as ts.Identifier).originalKeywordKind);
+//         //   // console.log('');
+//         // }
+//         break;
+//       case ts.SyntaxKind.VariableDeclaration:
+//         // const dec = n as ts.VariableDeclaration;
+//         // if (dec.name.kind === ts.SyntaxKind.Identifier) {
+//         //   mc.declarations.set((dec.name as ts.Identifier).text, dec.type);
+//         // }
+//         break;
+//     }
+//
+//     firstPassVisitor(n, mc, tc);
+//   });
+// }

From ebc9d7d7d0ccca28941fbed2c0eb4897421f8c6c Mon Sep 17 00:00:00 2001
From: Fabian Pirklbauer <fabian.pirklbauer@gmail.com>
Date: Thu, 23 Mar 2017 16:33:57 +0100
Subject: [PATCH 26/26] Changes to tsconfig excludes.

---
 tsconfig.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tsconfig.json b/tsconfig.json
index d5ebef7..8dd2d2e 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -21,8 +21,8 @@
   ],
   "exclude": [
     "node_modules",
+    "src/playground/snippets",
     "dist",
-    "src/compiler/_archive",
-    "src/playground"
+    "src/compiler/_archive"
   ]
 }